UluAlgorandMCP

Server Quality Checklist

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

Latest release: v1.0.0
Disambiguation4/5
Most tools have distinct purposes, but get_protocol and get_protocol_summary could be confused since both return protocol information, though summary is specifically agent-friendly. identify_application and get_contract_role also overlap slightly, but their descriptions clarify the different focus.
Naming Consistency5/5
All tool names follow a consistent verb_noun pattern using clear verbs (get, identify, resolve, reverse_resolve, search). Naming is uniform with snake_case throughout, making the API predictable and easy to navigate.
Tool Count5/5
With 10 tools, the server is well-scoped for a read-only Algorand registry. Each tool covers a distinct lookup or identification need without unnecessary bloat, fitting comfortably within the ideal range.
Completeness4/5
The tool set covers protocol discovery, application/asset identification, contract roles, and name resolution (forward, reverse, and search). Minor gaps exist such as no list_assets or list_applications, but the core lookup workflows are well-supported.
Average 3.8/5 across 10 of 10 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

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

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

How is the quality score calculated?

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

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

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

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

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Get detailed information' without mentioning read-only behavior, return format, pagination, errors, or what 'detailed' includes. This is a minimal disclosure for a tool that lacks structured annotations.
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 redundant words or filler. It front-loads the key verb and resource, making it quickly understandable.
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?
For a single-parameter read tool with no output schema, the description is adequate but leaves gaps: it doesn't explain how to discover valid protocol IDs, what fields the 'detailed information' contains, or how this relates to sibling tools like get_protocols. It is minimally viable but not comprehensive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% (protocolId is described with an example). The description adds no additional meaning beyond the schema, but the baseline of 3 applies because the schema fully documents the parameter. No compensation needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get'), resource ('detailed information about a specific Algorand protocol'), and scope ('by ID'). It distinguishes itself from sibling tools like get_protocols (plural list), get_protocol_summary (summary only), and get_protocol_contracts (contracts specifically).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied: use when you need detailed info on a specific protocol by ID. However, the description does not explicitly state when to use this instead of get_protocols or get_protocol_summary, nor does it mention any prerequisites like fetching the ID first from get_protocols.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full burden. It only hints at the 'known' nature of the role but does not disclose whether the operation is read-only, what happens for unknown apps, or error handling. This is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that is front-loaded with the action, and the examples are informative without adding unnecessary length. No wasted words.
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 that the tool is simple with one documented parameter and no output schema, the description gives a clear idea of purpose and plausible outputs via examples. However, it does not explicitly describe return format or behavior for unknown applications, which is a minor gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3. The description adds no meaning beyond the schema's 'Application ID on Algorand'; the examples pertain to output values rather than parameter syntax or semantics.
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 'Get' and the resource 'known protocol role for an Algorand application', with concrete examples. This distinguishes it from sibling tools like get_protocols, which focus on protocols rather than application roles.
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 retrieving an application's protocol role, but provides no explicit context, preconditions, or comparison with alternatives like identify_application. It is self-explanatory but lacks direct guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden for behavioral disclosure. It only states 'List all known application contracts' but provides no information about whether this is a read-only operation, authentication requirements, pagination, response structure, or any side effects. The verb 'List' hints at safety but does not explicitly confirm it.
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 with no redundant information. It efficiently communicates the core functionality without unnecessary elaboration.
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 is simple (one parameter, no output schema), but the description is sparse. It fails to explain what the returned data looks like (just IDs? full contract details?) or how this tool relates to siblings such as get_contract_role or identify_application. This leaves the agent uncertain about the output and follow-up actions.
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 covers the single parameter (protocolId) with a clear description and an example, providing 100% coverage. The tool description does not add further meaning beyond what the schema already provides, so it stays at the baseline score.
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 resource ('known application contracts for an Algorand protocol'), which clearly distinguishes it from sibling tools like get_protocols or identify_application. It precisely indicates what the tool does.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is used to retrieve contracts for a specific protocol, and the parameter name 'protocolId' clarifies the required input. However, it does not explicitly mention alternatives or exclusions, though the purpose is clear enough that an agent can infer when to use it.
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. It discloses that the tool returns a list with type and description, which implies a read-only operation, but does not mention potential behavior such as pagination, rate limits, or whether the list is exhaustive. This is adequate for a simple listing tool but lacks depth.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that is front-loaded with the action ('List all') and the resource. Every word contributes meaning, with no filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with one optional parameter and no output schema, the description is fairly complete: it explains the purpose, the filter parameter, and the output fields. It does not mention pagination or ordering, but given the simplicity, those are likely not critical. It could be improved by explicitly noting the absence of side effects or clarifying that 'all' means no hidden pagination.
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 already provides 100% coverage for the 'type' parameter with a clear description and examples. The tool's description adds no extra parameter-specific semantic detail beyond mentioning that type is one of the output fields. Therefore, 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.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists all known Algorand protocols with their type and description, using the specific verb 'List all' and a clear resource. It distinguishes from singular get_protocol and detailed get_protocol_summary by emphasizing the enumeration aspect, but 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.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The usage context is implied: you use this tool when you want an overview of all available protocols, optionally filtered by type. However, the description does not explicitly state when to use this over sibling tools like get_protocol or get_protocol_summary, nor does it provide 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?
With no annotations, the description carries the full burden. It discloses that the output is concise and agent-friendly and lists covered aspects, but it does not mention error behavior, return format, or prerequisites such as protocol existence. Adequate but not comprehensive.
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, front-loaded sentence with no filler. Every phrase adds value: the action, the target audience, the resource, and the content scope.
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 one-parameter read-only tool with no output schema, the description sufficiently conveys what the tool returns and for what purpose. It lacks explicit return formatting, but the term 'summary' sets expectations well enough for tool selection.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the single parameter protocolId is already well described with examples. The description adds no input-specific detail; its mention of purpose, contracts, and assets describes output, not parameter semantics. Baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Get') and identifies a clear resource (an agent-friendly summary of an Algorand protocol), while explicitly listing its contents (purpose, contracts, assets). This distinguishes it from sibling tools like get_protocol (likely full details) and get_protocol_contracts (specific contracts).
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 word 'summary' implies use for high-level overviews, but there is no explicit statement about when to choose this over get_protocol or get_protocol_contracts. No alternative tools are named or exclusions given, so guidance is minimal.
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 bears full responsibility for disclosing behavioral traits. While 'identify' implies a read operation, the description does not explicitly state whether it is read-only, what happens for unknown IDs (though 'if known' hints at optional description), or any error behavior. This is a significant gap for a tool with no annotation support.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that immediately states the tool's purpose and return value. Every word contributes, with no redundancy or filler, 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?
For a simple one-parameter tool with no output schema and no annotations, the description covers the core purpose and return contents adequately. It lacks usage exclusions and explicit read-only confirmation, but the low complexity keeps it largely complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% coverage with a description for appId ('Application ID on Algorand'), so the schema handles the parameter meaning. The description's phrase 'by ID' adds minimal value and does not provide additional syntax or format details, keeping this at the baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'Identify' with the resource 'Algorand application by ID' and lists the exact return fields (protocol, role, type, description). This clearly distinguishes it from sibling tools like identify_asset, which handles assets, and get_protocol, which covers protocols.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is used when you have an Algorand application ID and want identifying information. It provides clear context but does not explicitly state when not to use it or mention alternatives such as identify_asset or get_contract_role, so it falls short of full exclusion guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/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 explicitly states the returned fields and adds a useful caveat ('if known'), implying some data may be absent. It also implies a read-only operation through the verb 'identify', though it does not explicitly state non-mutating behavior or error handling.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that front-loads the action and resource, then lists expected outputs. Every word earns its place with no redundancy or irrelevant detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (1 parameter, no output schema), the description adequately covers the return values and purpose. It could optionally mention error behavior or the meaning of 'protocol association', but for a lookup tool this is sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already fully documents the sole parameter (assetId: 'Asset ID on Algorand (0 for ALGO)'), so the description adds little beyond the schema. Baseline 3 is appropriate since schema coverage is 100%.
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 ('Identify') and resource ('Algorand asset by ID'), clearly distinguishing this from sibling tools like identify_application or get_protocol. It also states the intended output fields (name, symbol, type, protocol association, tags), making the tool's purpose unmistakable.
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 have an asset ID and want metadata') but does not explicitly state when to use this tool versus alternatives. There are no exclusions or when-not guidance, but the context is reasonably clear for a simple lookup tool.
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 transparency weight. It discloses that the lookup is from a static registry, implying a read-only operation, but does not detail failure behavior, result shape, or any edge cases. For a simple lookup tool, this is adequate but not rich.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences, directly stating the tool's function and providing an alternative for live resolution. Every word earns its place with no fluff or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter tool with no output schema, the description covers purpose, usage guidance, and a key behavioral trait (static registry). It doesn't explicitly state return values, but 'look up names' implies the output. Missing some detail but essentially complete for the tool's complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with the address parameter clearly described as 'Algorand wallet address to reverse-resolve'. The description adds no additional parameter semantics, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool looks up well-known Algorand names for an address, specifying the resource (names) and verb (look up). It distinguishes from siblings by noting it uses a static registry, and contrasts with live resolution alternatives, making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance to use UluCoreMCP or NFDomains API for live resolution, implying this tool is for static registry lookups. It doesn't explicitly mention sibling tools like resolve_name, but the static vs. live distinction gives clear usage context.
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 adds meaningful context: the registry is 'static' and returns '.algo names'. The word 'Search' implies a read-only operation, though read-only is not explicitly stated. It stops short of mentioning edge cases like empty results or case sensitivity.
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: 'Search the static Algorand name registry by pattern.' It conveys the essential purpose without any wasted words, and the second sentence clarifies the return value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one param, no output schema), the description is adequately complete. It states what it does and what it returns. It could mention empty-result behavior or ordering, but for a basic pattern search with a well-documented parameter, it covers the essential context.
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?
Input schema coverage is 100%, so the schema already fully describes the 'pattern' parameter. The description merely echoes 'by pattern' and adds no new detail about the parameter format beyond the schema's 'substring match' explanation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Search'), the resource ('static Algorand name registry'), and the specific scope ('by pattern'). It further clarifies the return value ('Returns matching .algo names'), distinguishing it from exact resolution tools like resolve_name and reverse_resolve_address.
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 phrase 'by pattern' implies usage when a partial name is known, but there is no explicit guidance on when not to use the tool or comparison with alternatives. No exclusions are stated, but the lack of direct reference to sibling resolution tools leaves the usage context only implied.
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. It discloses the key behavioral trait that this is a static registry lookup, not live resolution, which is important context. It does not cover error cases or side effects, but for a simple read lookup the core behavior is clear.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no wasted words. The first sentence states the purpose, the second provides usage guidance. Front-loaded and efficient.
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 lookup with complete schema metadata, the description sufficiently covers the core behavior and return type (address and metadata). It also differentiates from live-resolution tools. Minor gaps like error behavior are not critical for this tool's simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, and the description repeats the example format already in the schema. The description adds minimal extra meaning beyond the schema's own parameter description, so baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool resolves an Algorand name to its address and metadata, with a specific resource (names) and scope (static registry). It also distinguishes from live-resolution tools by explicitly mentioning the static registry and naming alternates.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says when to use this tool (for static registry resolution) and provides clear alternatives ('For live resolution, use UluCoreMCP or NFDomains API'). This gives the agent a direct decision rule.
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:

[![UluAlgorandMCP MCP server](https://glama.ai/mcp/servers/MaidToShelly/UluAlgorandMCP/badges/card.svg)](https://glama.ai/mcp/servers/MaidToShelly/UluAlgorandMCP)

Score Badge

Copy to your README.md:

[![UluAlgorandMCP MCP server](https://glama.ai/mcp/servers/MaidToShelly/UluAlgorandMCP/badges/score.svg)](https://glama.ai/mcp/servers/MaidToShelly/UluAlgorandMCP)

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/MaidToShelly/UluAlgorandMCP'

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