bloodhound

by The-bub

Overview Schema Related Servers Score Discussions

Python

Local

Server Quality Checklist

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

Latest release: v2.0.0
Disambiguation5/5
Each tool targets a distinct operation: generic graph access (get_schema, run_cypher, search_object, node_details), prebuilt vulnerability queries (kerberoastable, dcsync, rbcd, etc.), path analysis (shortest_path, paths_to_tier0, blast_radius), and ownership tracking (mark_owned, list_owned, paths_from_owned). Even related path tools differ in starting point and goal, so no two tools are easily confused.
Naming Consistency4/5
All names use snake_case and are short, but the pattern is mixed: some are verb-led (get_schema, search_object, mark_owned), others are noun-led or technique names (domain_admins, kerberoastable, dcsync). This is a minor deviation from a strict verb_noun convention, but it remains readable and predictable within the BloodHound domain.
Tool Count4/5
With 23 tools, the server is on the heavier side of the ideal range, but BloodHound's broad feature set (generic queries, attack paths, delegation checks, ownership) justifies the count. Each tool serves a distinct, practical purpose without redundant entries.
Completeness4/5
The server covers core BloodHound workflows: arbitrary read-only queries, node lookups, common attack vector detection, path analysis, and owned-object management. Some expected operations like direct group membership listing or session hunting are absent, but run_cypher allows agents to work around these gaps, so the surface is not severely incomplete.
Average 3/5 across 23 of 23 tools scored. Lowest: 1.5/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 4 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is failing
Add a LICENSE file by following GitHub's guide. Once GitHub recognizes the license, the system will automatically detect it within a few hours.
If the license does not appear after some time, you can manually trigger a new scan using the MCP server admin interface.
MCP servers without a LICENSE cannot be installed.
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

Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations, and the description does not disclose whether the operation is read-only, what it returns, or any side effects. The default Cypher query suggests a read operation, but the description itself provides no behavioral information.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The text is short but under-specified. It consists of a vague phrase and a parenthetical note, neither of which conveys essential functional information. This is under-specification, not effective conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/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 and usage context. It only provides a label and a verification note, leaving the agent without enough information to invoke the tool correctly, especially given similar sibling tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not explain the parameters k and cy or their purposes. The defaults are visible in the schema, but the description adds no meaning to help an agent understand or configure the query.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose2/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Tier-0 objects' restates the tool name without specifying an action such as 'list' or 'get'. It mentions the CE label Tag_Tier_Zero but does not clarify what the tool does, making it hard to distinguish from siblings like paths_to_tier0.
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 guidance is given on when to use this tool versus alternatives such as run_cypher or paths_to_tier0. The parenthetical 'requête vérifiée' (verified query) hints at pre-validated logic but does not explain use cases or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, and the description offers no details about side effects, read-only nature, required permissions, or output format. The parenthetical 'requête vérifiée' is opaque and adds no 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.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely brief but underspecified; the added parenthetical 'requête vérifiée' provides no actionable information. It is not a model of conciseness because it sacrifices essential content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and no parameter documentation, the description fails to explain what the query returns, how results are structured, or what the parameters do. A prebuilt query tool like this needs more context to be invoked correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema contains parameters k and cy with defaults but no descriptions. The tool description does not explain their purpose or how they affect the query, leaving the agent without guidance.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Trust relationships between domains' identifies the subject matter but lacks an action verb, making it ambiguous what the tool does with trust relationships (list, create, delete). It does not distinguish from sibling tools like run_cypher, which could also be used to retrieve this data.
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 usage context is provided. The description does not indicate when to use this tool versus generic alternatives like run_cypher, nor does it mention any prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description bears the full burden of behavioral disclosure. It does not state whether the tool runs a read-only query, whether it accesses live data or cached results, or what side effects it might have. The only additional note, 'requête vérifiée' (verified query), adds little behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, which is concise. However, it is under-specified and the French note '(requête vérifiée)' adds marginal value. It is not verbose, but it sacrifices substance for brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no annotations, no output schema, and only a minimal description, it is far from complete. The agent cannot determine what parameters to pass, what the return value looks like, or when to invoke this tool. The description only states the result set, leaving too much unspecified for reliable use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema defines two parameters (k and cy) but provides no descriptions, and the tool description does not mention them. With 0% schema description coverage, the agent has no way to infer the meaning or purpose of these parameters. The default Cypher query is visible but not explained.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool's purpose: to return enabled users that do not require Kerberos pre-auth (AS-REP roastable). It names a specific resource (users) and a condition (AS-REP roastable), which distinguishes it from siblings like kerberoastable. However, it lacks an explicit verb such as 'list' or 'find', so it reads more like a label than an action.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines1/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It does not mention scenarios, prerequisites, or related tools like kerberoastable or run_cypher. There is no explicit when/when-not guidance, leaving the agent without contextual direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior1/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 only says '(requête vérifiée)' which provides no meaningful behavioral information. It does not disclose that the tool executes a Cypher query, whether it is read-only, or what the output format is.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely short and front-loaded, but it under-specifies the tool's behavior and parameters. It is concise in length but not appropriately sized for the tool's complexity, as it omits critical information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no annotations, no output schema, and no parameter guidance, the description is completely inadequate. It only provides a noun phrase and a vague note, leaving the agent without enough context to invoke the tool correctly or interpret results.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage, and the description does not mention the parameters k and cy at all. The user cannot determine what these parameters control or how to adjust them, making the tool effectively unusable without external knowledge.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the resource (Domain Controllers) and adds the specific scope (members of the -516 group), which distinguishes it from sibling tools. However, it lacks an explicit verb like 'list' or 'get', so the action is implied rather than stated directly.
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?
There is no guidance on when to use this tool vs alternatives such as run_cypher or search_object. The description does not mention any use cases, prerequisites, or exclusions, leaving the agent without decision criteria.
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, the description carries the full burden of disclosing behavior, but it does not state that this is a read-only query, whether it executes a fixed or customizable query, or what the response looks like. The phrase 'requête vérifiée' vaguely alludes to safety but is ambiguous and not explanatory.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short noun phrase, so it is technically concise with no wasted words. However, it is under-specified, missing a verb and actionable content, making it less effective than a complete yet compact sentence.
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 no annotations, no output schema, and only two parameters, but the description does not explain how to invoke the tool, what the parameters mean, or any constraints. It does not mention that this is a specialized wrapper around a Cypher query, nor how it relates to run_cypher.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not explain the purpose of parameters 'k' or 'cy'. The default value of 'cy' provides a full Cypher query, offering some implicit semantics, but the description itself adds no parameter-level meaning or usage guidance.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description names the resource ('Principals with constrained delegation') and the output ('their allowed targets'), establishing subject matter, but it lacks a verb and does not distinguish this tool from sibling tools like unconstrained_delegation or run_cypher. It is more of a label than an explicit statement of action.
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 guidance is given on when to use this tool versus alternatives such as run_cypher or unconstrained_delegation. There is no mention of prerequisites, whether the query is read-only, or any conditions under which this tool is preferred.
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 must disclose behavioral traits. It only states a fact and adds '(requête vérifiée)', which is a vague assurance. It does not mention that the tool executes a Cypher query (visible only in the schema default), that it is a read-only operation, or what fields are returned. The behavior is largely hidden.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence, which is concise. However, it is under-specified and does not provide necessary structure (e.g., sections, usage examples, or parameter notes). It is not verbose but also not a well-formed tool description.
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?
Without an output schema or annotations, the description is the primary source of context. It only identifies a high-level result without detailing the returned fields (which are actually visible in the default Cypher query), permissions, or side effects. Given the tool's moderate complexity and many siblings, this is insufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema defines two parameters (k and cy) with default values, but there are no descriptions. The schema description coverage is 0%, and the tool description does not explain these parameters at all. The defaults hint that cy is the Cypher query and k is a key, but the description fails to compensate for the lack of schema documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Enabled users with an SPN (Kerberoastable)' clearly identifies the tool's purpose: listing users with a Service Principal Name who are enabled, making them kerberoastable. It uses a specific noun phrase that differentiates from siblings like 'asrep_roastable' or 'unconstrained_delegation', though it could be more explicit (e.g., 'List enabled users with an SPN' as a verb phrase).
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?
There is no guidance on when to use this tool versus alternatives. The description does not mention any conditions, prerequisites, or exclusions. It only states the output. No sibling tools are referenced, and the context for selection is absent.
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. It merely states what the tool returns, without disclosing whether it is read-only, whether it executes a query, any permissions needed, or potential side effects. The parenthetical '(requête vérifiée)' adds minimal transparency about query verification but does not compensate for the lack of behavioral detail.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very concise, a single phrase with a parenthetical note. It is front-loaded with the key information (principals and computers). It avoids unnecessary words, but the lack of a verb slightly reduces clarity.
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?
For a tool with no annotations and no output schema, the description is incomplete. It does not describe the return format, whether results are ordered (though the default query has an ORDER BY), or any limitations. It gives no context on how to interpret the results or when this query might be relevant in a security assessment.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description should explain the parameters k and cy. It does not. The defaults in the schema show a Cypher query, but the description gives no indication that these parameters customize the query or what each parameter controls. The description adds no value for parameter understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool returns principals that can read LAPS passwords and the computers involved. It clearly identifies the resource (LAPS passwords) and the result (principals and computers), distinguishing it from similar tools like can_read_gmsa. However, it lacks a concrete verb (e.g., 'List' or 'Find'), relying instead on a noun phrase.
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 guidance is provided on when to use this tool versus alternatives such as can_read_gmsa or run_cypher. There is no mention of exclusions, prerequisites, or preferred contexts. The usage is only implied by the tool name and description.
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 of behavioral disclosure. It does not mention that this is a read-only query, what the output format looks like, or any potential performance or permission considerations. The phrase 'requête vérifiée' adds limited credibility but no behavioral detail.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no redundant wording. It efficiently conveys the core purpose, but it omits essential context, making it under-specified rather than appropriately concise.
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?
Given that there is no output schema, no annotations, and the tool is a specialized query among many siblings, the description is too thin. It does not explain the return format, parameter usage, or when to choose this over similar tools, leaving significant gaps in the agent's ability to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has two parameters (k and cy) but provides no descriptions, and schema description coverage is 0%. The description does not compensate by explaining these parameters or how they influence the query. The agent would have no way to know what k and cy should contain beyond the default values.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states that it identifies principals that can DCSync a domain, with the specific permissions GetChanges + GetChangesAll. This clearly indicates the tool's function and differentiates it from sibling tools that target other AD attack paths, though it lacks an explicit verb and directly names no sibling alternatives.
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?
There is no guidance on when to use this tool versus alternatives like 'run_cypher', 'domain_admins', or other predefined queries. The description does not state appropriate scenarios, prerequisites, or exclusions, leaving the agent to infer usage from the name alone.
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, the description carries the full burden but provides minimal behavioral detail. It does not disclose that the tool executes a predefined Cypher query, whether it is read-only, or what the output shape is. The note 'requête vérifiée' is vague and does not inform about side effects or return values.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise, using only a noun phrase and a parenthetical note. It contains no redundant language, but the fragmentary structure and French phrase may reduce clarity for non-French speakers.
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?
Given no annotations, no output schema, and a sparse description, the tool is incomplete. It conveys the domain concept (RBCD) but omits critical context about execution, customization, and expected results. The defaults for both parameters are not explained, leaving an agent to infer behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description entirely ignores the parameters 'k' and 'cy'. Since schema description coverage is 0%, the description should compensate, but it remains silent. The only hints are the defaults in the schema, which are not explained.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description identifies the tool as handling 'Resource-based constrained delegation (AllowedToAct)', which clearly distinguishes it from sibling tools like 'constrained_delegation' and 'unconstrained_delegation'. However, it lacks an explicit verb (e.g., 'lists' or 'finds'), so the action the tool performs must be inferred from context.
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 offers no explicit guidance on when to use this tool versus alternatives such as 'constrained_delegation' or 'run_cypher'. The phrase 'requête vérifiée' (verified query) does not provide usage context or prerequisites.
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 only mentions 'requête vérifiée' (verified query), which suggests safety but does not explain that this executes a read-only Cypher query, returns specific fields, or any potential performance implications. The underlying query is visible in the schema but not explained in the description.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no repetitive or unnecessary content. It is front-loaded with the key information (users and computers with unconstrained delegation). However, it is so brief that it borders on under-specification, which slightly reduces the score.
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 description is too minimal for an agent to confidently choose this tool over the similar constrained_delegation sibling. It does not explain what the tool returns, what the output looks like, or the context in which unconstrained delegation is relevant. Given there is no output schema, the description should do more to set expectations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description provides no explanation of the parameters 'k' and 'cy'. An agent seeing only the description would have no idea what these parameters mean or how to modify them. Although defaults are present, the lack of any semantic guidance makes this a significant gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the resource (unconstrained delegation) and the entity types (users and computers). It implicitly distinguishes itself from the sibling 'constrained_delegation' via the word 'unconstrained'. However, it lacks an explicit verb like 'List' or 'Show', making it a noun phrase rather than a clear action statement.
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?
There is no guidance on when to use this tool versus alternatives such as constrained_delegation or run_cypher. No use cases, prerequisites, or exclusions are provided, leaving the agent to guess the appropriate context.
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, the description carries the full burden. It does not mention whether the operation is read-only, any authentication requirements, or the structure of the result. It only states the core computation.
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?
Single sentence, no redundant information, front-loaded and to the point.
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?
Although an output schema exists, the description is too brief to fully contextualize the tool's role among its siblings, lacks usage guidance, and does not define domain-specific terms like 'abusable edges'. For a complex graph query, more context is needed.
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 description maps 'principal' to the source parameter and 'N hops' to max_hops, providing some meaning beyond the schema. However, it does not clarify the notion of 'abusable edges' or constraints on hop values, leaving some ambiguity.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly conveys that the tool computes reachability from a principal through abusable edges within a hop limit. It distinguishes from sibling tools like shortest_path by focusing on abusable edges, though it lacks an explicit verb like 'find' or 'list'.
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 guidance on when to use this tool compared to alternatives like shortest_path or paths_to_tier0. It does not state exclusions or prerequisites.
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. It only states the purpose and does not disclose that this is a read-only query, any security implications, or what the output will look like.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a short phrase but includes a valueless parenthetical '(requête vérifiée)'. It is not verbose, but it is under-specified and lacks a clear sentence structure.
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?
Given no annotations and no output schema, the description is insufficient. It does not explain the query's behavior, return format, or prerequisites. For a tool in a family of similar query tools, more context is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has two parameters (k and cy) with defaults, but the description does not explain their roles. With 0% schema coverage, the description fails to compensate by mentioning that cy is a Cypher query or that the tool executes a query.
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: finding principals that can read gMSA passwords. This is a specific verb+resource and distinguishes it from sibling tools like can_read_laps.
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 guidance on when to use this tool or how it compares to alternatives such as can_read_laps. It is a bare statement with no usage context.
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 of behavioral disclosure. It does reveal an important trait: membership includes both direct and nested members across all Domain Admins groups. However, it omits other potentially relevant details such as read-only nature, permission needs, or output format, which limits transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that is front-loaded with the key information. However, the appended French phrase '(requête vérifiée)' is unnecessary for an English-speaking AI agent and adds no semantic value, preventing a perfect score.
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 no output schema, and the description provides only a high-level statement of what is returned (members) without detailing the output structure (e.g., fields like name and group). Combined with absent parameter guidance and usage context, the description is incomplete for a tool with only minimal structured metadata.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description provides no explanation of the parameters 'k' and 'cy'. Although the defaults hint at a key and a Cypher query, the description does not clarify their meaning or usage, failing to compensate for the schema's lack of documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns 'Members (direct + nested) of every Domain Admins group', which is a specific resource and scope. It lacks an explicit verb like 'list' or 'retrieve', but the noun phrase is unambiguous and distinguishes it from sibling tools that target other AD objects or queries.
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 guidance is provided on when to use this tool versus alternatives such as tier_zero, domain_controllers, or run_cypher. The description does not mention any prerequisites, exclusions, or situational context, leaving the AI agent without clarity on specific use cases.
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. It implies a read-only analysis tool but does not disclose how 'owned' is determined, whether it relies on pre-marked objects, or any permissions/side effects. It also does not mention pagination or the meaning of the optional parameters.
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 with no filler words. It is front-loaded with the primary purpose and is appropriately sized for a straightforward tool.
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 has an output schema that documents return values, but the description lacks explanation of key domain concepts (what qualifies as 'owned', how paths are computed). Given the sibling tools and the presence of an output schema, the description is minimally adequate but leaves gaps in usage and parameter meaning.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage, and the tool description does not explain 'limit' or 'max_hops' at all. The description fails to compensate for the lack of schema descriptions, leaving parameter semantics entirely undocumented.
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 identifies a specific resource and scope: 'Shortest attack paths from any owned principal to tier-0.' It differentiates from siblings like paths_to_tier0 by explicitly focusing on owned principals, and the verb 'find/return' is implied. This is precise 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 Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when the user wants attack paths starting from owned principals, but it does not explicitly state when to use this tool versus alternatives like paths_to_tier0 or shortest_path. There is no exclusionary guidance, but the scope is hinted.
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 full behavioral burden. However, it only states the function without disclosing whether it is read-only, how paths are computed, or any side effects/limitations. This is a significant gap for a path enumeration tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, focused sentence efficiently conveys the core function with no filler or unnecessary words. It is appropriately front-loaded, though it sacrifices detail for brevity.
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 having an output schema, the description is too sparse to contextualize the three parameters, the meaning of 'shortest attack paths,' or how this tool relates to siblings like shortest_path and tier_zero. More detail is needed for a security analysis tool with no annotations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so the description must explain parameters. It implicitly explains 'source' as a principal, but leaves 'limit' and 'max_hops' completely unexplained. The schema only provides types and defaults, not meaning.
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 computes shortest attack paths from a principal to tier-0 objects, using a specific verb ('Shortest attack paths') and resource ('tier-0 object'). This distinguishes it from generic path tools like shortest_path and list tools like domain_admins.
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—when you need attack paths to tier-0—but provides no explicit guidance on when not to use it or which sibling tool to choose instead. It states the scenario but lacks exclusions or alternatives.
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 provided, the description carries the full burden of behavioral disclosure. It correctly suggests a read-only listing operation via 'List', but does not explicitly state side-effect-freeness, authentication requirements, or whether the result set is limited to specific principal types. This is acceptable for a simple list tool, but lacks added clarity beyond the name.
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 with no filler or redundant details. Every word contributes to the meaning, 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 has no parameters, an output schema exists, and it is a straightforward listing operation, the description provides sufficient context for basic understanding. It does not elaborate on the concept of 'owned' or return value structure, but the output schema and sibling tools help fill gaps, and the simplicity of the tool reduces the burden on the description.
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?
The tool takes zero parameters, so the input schema is trivially complete. The description does not need to explain parameter semantics, and the baseline for 0-parameter tools is 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'List principals currently marked as owned' uses a specific verb ('List') and resource ('principals marked as owned'), clearly indicating the tool's function. However, it does not explicitly differentiate from sibling tools like 'mark_owned' or 'paths_from_owned', though the distinction is easily inferred.
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—use this tool to see which principals are currently owned—but provides no explicit context for when to choose it over alternatives. No when-to-use or exclusionary guidance is given, so it relies on the user to infer applicability.
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 exist, so the description carries the full burden. It discloses that the tool returns full properties and inbound/outbound edge counts, which is the core behavior. However, it does not mention permissions, error handling for nonexistent nodes, or any potential performance impacts, leaving some behavioral gaps.
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 one concise sentence that front-loads the key purpose and input constraint. Every word contributes to understanding the tool's function, with no wasted 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?
Given the simple single-parameter input and presence of an output schema, the description covers the main purpose and input. However, it lacks additional context about potential edge cases or prerequisites (e.g., node must exist) and does not clarify if edge counts are inclusive of both directions or just summarized by type. This is adequate for a basic lookup tool but not 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?
The schema only shows a single 'target' string with no description. The description compensates by indicating the target is a node name or object ID, adding meaning beyond the bare schema. Yet it lacks details on format (e.g., case sensitivity, exact name resolution rules), so it only partially compensates.
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 returns full node properties and edge counts by type, with the input specified as name or object ID. This is a specific operation on a resource and distinguishes it from siblings like search_object or run_cypher.
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 usage is implied: use this tool when you need complete node details and edge counts. However, there is no explicit guidance on when not to use it or reference to alternative tools (e.g., search_object for quick lookup), so it falls short of explicit context.
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 must carry the burden of disclosure. It accurately describes the search behavior and label options but omits details like default limit, case sensitivity, and return format. Search semantics are understandable, but some behavioral specifics 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?
A single sentence that is front-loaded with the action and resource, then lists the optional filter. Every word contributes meaning, with no 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?
An output schema exists, so return values are defined. The description covers the essential functionality for a simple search tool but does not explain the default label behavior or how the limit interacts with results. Given the tool's straightforward nature, it is sufficiently complete.
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 0%, and the description compensates well by explaining that 'term' is matched against name/objectid and enumerating allowed label values. The 'limit' parameter is self-explanatory from its name and default, though not explicitly described.
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 verb 'Find' and the resource 'objects', specifying that it searches name/objectid by a term. It also provides the optional label filter with a list of possible values, distinguishing it from specialized sibling tools.
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 guidance on when to use this tool versus alternatives like run_cypher or other search utilities. The description implies searching by simple term, but lacks exclusions or alternative suggestions.
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 provided, the description carries full responsibility for behavioral disclosure. It does disclose that the mark is stored app-side and not written to the DB, which is a key behavioral trait. However, it does not mention idempotency, permission requirements, or whether marking overwrites existing state, leaving some gaps.
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, focused sentence that front-loads the verb and resource, with no wasted words. It efficiently conveys purpose and key behavior without verbosity.
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 one-parameter tool with an output schema, the description provides adequate information: what the tool does, the target format, and the crucial storage detail. It does not explain how the marking affects other tools (e.g., paths_from_owned), but this is reasonably inferable given the sibling context.
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?
The input schema only defines 'target' as a string with no description. The description adds crucial meaning by stating 'by name/objectid', clarifying what the string should represent. This compensates for the 0% schema coverage effectively, though it could be more explicit about format.
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: to mark a principal as attacker-owned. It specifies the target type (name/objectid) and distinguishes this from listing owned principals (as in sibling tools like list_owned) by noting the app-side storage.
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—mark principals you have compromised—but does not provide explicit guidance on when to use this tool versus alternatives like list_owned or other state-modifying tools. The 'stored app-side' detail gives some context but no direct comparison or exclusions.
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?
The description discloses what information is returned but does not explicitly state whether it is read-only or mention any permissions or side effects. With no annotations, the description carries the full burden, and while it gives moderate insight into the tool's behavior, it lacks explicit safety guarantees or operational caveats.
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. It leads with the purpose ('Security triage of a principal'), then specifies identifier types and the scope of information, with no redundancy or fluff.
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?
With only one parameter, an output schema in place, and a list of included data categories, the description gives a solid overview. It lacks nuance around terms like 'who controls it' but is otherwise complete for a read-oriented triage tool.
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?
The description adds significant meaning to the otherwise undecorated 'target' parameter by specifying that it accepts a principal name or objectid. This compensates for the 0% schema coverage, though it does not provide format examples or distinguish between name types (e.g., sAMAccountName vs UPN).
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 'triage' and clearly identifies the resource (a principal) and identifier types (name or objectid). It lists the four categories of information returned (attributes, memberships, controllers, tier-0 distance), which distinguishes it from sibling tools like node_details or tier_zero.
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: use for security triage of a principal, covering attributes, memberships, control, and tier-0 distance. It does not explicitly name alternative tools or state when not to use it, so it stops short of a full 5.
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 transparency burden. It discloses a key behavioral trait: only abusable edges are considered by default, and the include_structural flag changes this. This adds meaningful context beyond what a naive description would provide, though it does not discuss edge cases or prerequisites.
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, front-loaded with the tool's purpose. Every phrase adds value: the node specification, the default edge filter, and the optional flag. No filler or redundant repetition of schema titles.
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 moderate complexity and the presence of an output schema, the description is adequately complete. It covers the main functional distinction (abusable vs structural edges) and the input format for nodes. It does not elaborate on return values (covered by output schema) or limitations, but this is acceptable for a path-finding 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 0%, so the description must compensate. It clarifies that source and target are specified 'by name/objectid', and explains the include_structural flag's meaning. However, it does not mention the max_hops parameter or its default, leaving part of the parameter semantics to the schema alone.
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 'Shortest attack path between two nodes', specifying the verb 'finds' (implied) and the resource (attack path), with a specific scope of 'between two nodes'. This distinguishes it from sibling tools like paths_to_tier0 or blast_radius, which target different node sets.
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 gives clear context: it is for finding the shortest path between two specified nodes, and explains the default 'abusable edges' behavior with an option to include structural edges. However, it does not explicitly mention alternatives or when not to use this tool, though it is implied by the phrase 'between two nodes'.
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 full burden. The verb 'List' suggests a read-only operation, and the phrase 'with per-label counts' adds useful detail about the returned data. However, it does not mention any potential performance implications or whether all graph elements are always included.
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?
A single concise sentence that fully describes the tool's function with no fluff or repetition. It is front-loaded with the action and resource and leaves no wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given zero parameters, an output schema, and a simple read-only purpose, the description is sufficiently complete. The tool's behavior is fully captured, and the presence of an output schema means return value details are handled elsewhere.
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?
This tool has no parameters, so baseline 4 applies. The input schema is an empty object, and the description correctly does not attempt to explain nonexistent parameters.
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 'List' and clearly identifies the resource: node labels, relationship types, and property keys with per-label counts. It is unambiguous and distinguishes from sibling tools like run_cypher or search_object by focusing on schema introspection.
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 for schema discovery but does not explicitly state when to use it over alternatives like run_cypher or provide any exclusions. A user could infer it as the go-to for schema listing, but no direct guidance is given.
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 burden of behavioral disclosure. It clearly states the read-only nature and that writes/procedure calls are rejected, which is a key behavioral trait. It doesn't elaborate on error handling or return format, but the presence of an output schema reduces that need. The 'Prefer the dedicated tools' also conveys that this is a last resort.
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 terse sentences with all necessary information front-loaded. No word is wasted, and it conveys purpose, constraints, and usage guidance efficiently.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the low complexity (one parameter), the presence of an output schema, and the clear read-only constraint, the description covers everything an agent needs to invoke the tool correctly. It doesn't need to explain return values because the output schema exists. The guidance to prefer dedicated tools also helps contextual decision-making.
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 has 0% description coverage, and the description does not detail the 'query' parameter beyond implying it is a Cypher query. This is some additional context, but the parameter name 'query' and type 'string' are self-explanatory. The description could enhance semantics by mentioning query examples or limits, but it is adequate for a single straightforward parameter.
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: 'Run a READ-ONLY Cypher query.' It specifies the resource (Cypher query) and differentiates from sibling tools by noting it is a generic fallback while dedicated tools exist. The constraints on writes and procedure calls further clarify its scope.
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 says to prefer dedicated tools, providing a clear alternative. It also specifies that writes and procedure CALLs are rejected, which implicitly guides when not to use this tool. However, it doesn't enumerate the dedicated tools or provide specific scenarios for when this fallback is appropriate, leaving a minor gap.
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:

[![Agent-BloodHound MCP server](https://glama.ai/mcp/servers/The-bub/Agent-BloodHound/badges/card.svg)](https://glama.ai/mcp/servers/The-bub/Agent-BloodHound)

Score Badge

Copy to your README.md:

[![Agent-BloodHound MCP server](https://glama.ai/mcp/servers/The-bub/Agent-BloodHound/badges/score.svg)](https://glama.ai/mcp/servers/The-bub/Agent-BloodHound)

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/The-bub/Agent-BloodHound'

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