gblin-mcp-server
Server Details
Collateral-backed treasury vault for AI agents on Base. Crash Shield defends, JIT pays x402.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP
- URL
- Repository
- gblinproject/GBLIN-MCP
- GitHub Stars
- 1
- Server Listing
- @gblin-protocol/mcp-server
Glama MCP Gateway
Connect through Glama MCP Gateway for full control over tool access and complete visibility into every call.
Full call logging
Every tool call is logged with complete inputs and outputs, so you can debug issues and audit what your agents are doing.
Tool access control
Enable or disable individual tools per connector, so you decide what your agents can and cannot do.
Managed credentials
Glama handles OAuth flows, token storage, and automatic rotation, so credentials never expire on your clients.
Usage analytics
See which tools your agents call, how often, and when, so you can understand usage patterns and catch anomalies.
Tool Definition Quality
Average 4.1/5 across 5 of 5 tools scored.
Each tool serves a clearly distinct purpose: market stats, a free sample, a live risk regime read, protocol docs, and purchase instructions. The relationships between them are explicitly cross-referenced (sample vs live, free vs paid), making selection unambiguous.
All tools follow a consistent get_/how_to_ prefix pattern with descriptive noun tails. The exception is how_to_buy_live_attestation, which uses a how_to_ prefix rather than get_, but this is semantically sensible for an instructional tool and still follows a recognizable convention.
Five tools is well-scoped for a protocol observatory server covering stats, documentation, sample data, live data, and purchase guidance. Each tool earns its place without redundancy or bloat.
The surface covers the core protocol surface well: discovery (protocol_info), free data (stats, risk regime, sample), and the paid path (buy instructions). A minor gap is the absence of the actual paid attestation endpoint itself, though the instructions clearly lead there, justifying a 4 rather than 5.
Available Tools
5 toolsget_agent_economy_statsARead-onlyIdempotentInspect
Public GBLIN agent-economy observatory stats (x402 calls, payers, on-chain counters). Cached.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, covering the safety profile well. The description adds useful context by stating 'Cached' (stale-data behavior) and 'Public' (no auth/access requirements needed). No contradiction with annotations. It adds behavioral value beyond the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence delivers purpose and key behavioral cues ('Public', 'Cached') with zero filler. Every word earns its place. The 'Cached' note is valuable and wouldn't be inferable from the schema or annotations.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no parameters and no required inputs, making it a simple call. An output schema exists, so return values needn't be documented in the description. The description covers purpose, access level, and caching. Adequate for a zero-input, read-only tool, though it could name the specific units or formats of the returned stats.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are zero parameters (0, 0 required), so the baseline of 4 applies — there's nothing for the description to clarify. The schema coverage is meaningful at 100% with an empty object, so no parameter documentation burden exists.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns 'Public GBLIN agent-economy observatory stats' and lists specific data categories (x402 calls, payers, on-chain counters). The verb 'get' plus specific resource 'agent-economy stats' distinguishes it from siblings like get_market_risk_regime or get_protocol_info, though it doesn't explicitly name alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives context cues like 'Public' and 'Cached' but doesn't explicitly state when to use this tool vs alternatives. The sibling set (attestation_sample, market_risk_regime, protocol_info) are semantically distinct enough that the purpose implies usage, but there's no explicit when/when-not guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_attestation_sampleARead-onlyIdempotentInspect
FREE static sample of the paid Risk Attestation: identical shape and EIP-712 schema, sample:true, permanently expired. Wire your parser/verifier against this, then switch to the paid endpoint.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| meta | No | |
| eip712 | No | EIP-712 domain/types/message to recompute the digest |
| sample | Yes | Always true — never a live signal |
| signed | Yes | |
| verify | No | |
| attestor | No | |
| signature | No | |
| attestation | Yes | Same field contract as the paid attestation (regime, shield_active, severity_pct, defensive_cash_pct, expires_at, ...) |
| attestation_id | Yes | hashTypedData digest — recompute to verify |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the agent knows this is a safe, non-mutating call. The description adds valuable behavioral context beyond annotations: it's FREE, static, permanently expired, and returns the same EIP-712 schema shape, which tells the agent exactly what to expect without invoking it.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence packed with dense, useful information: cost (free), recency (static), validity (expired), schema compatibility (identical EIP-712 shape), and usage intent (wire against then switch). Zero wasted words, maximum signal density.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This is a zero-parameter, description-carrying tool with an output schema provided. The output schema handles return format documentation, annotations cover safety, and the description explains the purpose, limitations (expired, static), and migration path to paid. Completely adequate for the tool's simplicity and well-supported by structured metadata.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are 0 parameters, so the description carries no parameter documentation burden. Per the guidelines, 0 params yields a baseline of 4. The description appropriately emphasizes that no input is needed (static, sample, permanently expired) and the output shape is described, so nothing is undocumented.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states this is a static sample of the Risk Attestation with identical shape and EIP-712 schema, distinguishing it from the paid endpoint. The verb 'get' + specific resource 'attestation_sample' with explicit 'sample:true, permanently expired' characteristics makes the purpose unambiguous and distinct from siblings like get_market_risk_regime and get_protocol_info.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage guidance: 'Wire your parser/verifier against this, then switch to the paid endpoint.' This tells the agent exactly when to use this tool (development/testing) and what the alternative path is (the paid endpoint, presumably accessed via how_to_buy_live_attestation). This is exemplary usage guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_market_risk_regimeARead-onlyIdempotentInspect
Current BTC/ETH market risk regime (calm | elevated | crash) read live from GBLIN's on-chain Crash Shield on Base mainnet. Free. Same math as the paid EIP-712 attestation, but unsigned — for a signed, attachable proof buy the x402 attestation (see how_to_buy_live_attestation).
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| note | No | |
| assets | Yes | Per-risk-asset shield state |
| regime | Yes | Current risk regime |
| source | No | |
| chain_id | No | |
| contract | No | GBLIN contract on Base |
| regime_code | Yes | 0 calm, 1 elevated, 2 crash |
| risk_posture | No | Suggested posture |
| severity_pct | Yes | Max crash-shield weight cut across risk assets, percent |
| shield_active | Yes | True when any risk asset is currently slashed |
| defensive_cash_pct | Yes | USDC dynamic weight in the basket, percent |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, openWorldHint=true, and idempotentHint=true, covering the safety profile. The description adds behavioral value by stating 'Free,' that the output is unsigned (no attachable proof), and that it uses the same math as the paid attestation. It discloses the counterpart of what this tool does NOT provide (signed proof).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, information-dense, zero filler. Every clause adds value: the output type, the source, the cost, the signing limitation, and the pointer to the paid alternative. Striking an excellent balance of completeness with brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple (no parameters), has rich annotations, and an output schema exists, so the description doesn't need to explain return values. The description covers source, cost, unsigned nature, and the sibling path for signed proofs. Could add the supported symbols scope (BTC/ETH already mentioned) or staleness info, but this is complete for its simple footprint.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so schema coverage is trivially 100%. The description establishes the output semantics by enumerating the possible regime values (calm | elevated | crash) and identifying the data source (GBLIN Crash Shield on Base mainnet), which meaningfully frames what an empty-parameter call returns.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool reads the current BTC/ETH market risk regime from GBLIN's on-chain Crash Shield on Base mainnet, with explicit output values (calm | elevated | crash). It distinguishes itself from the paid signed attestation variant and names a related sibling (how_to_buy_live_attestation). Specific verb (read), resource (Crash Shield), and scope (BTC/ETH risk regime) are all present.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description indicates this is the free/unsigned version to use when a signed proof is not required, and points to how_to_buy_live_attestation for the paid signed version. This gives clear context on when to use this tool vs the alternative, though it doesn't explicitly state 'use this tool when you only need live risk data without proof.'
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_protocol_infoARead-onlyIdempotentInspect
GBLIN protocol overview for agents (llms.txt): contracts, endpoints, prices, payment flow, field contract of the attestation.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| llms_txt | Yes | The full llms.txt document (plain text) |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations are rich (readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false) and the description aligns without contradicting them. The description adds value by clarifying this is a static llms.txt-style reference document (free, protocol-level info) rather than dynamic market data. It also enumerates what content the overview covers, giving the agent expectations about the return payload.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that packs meaningful content: the tool's purpose (overview), intended audience (agents/llms.txt), and the enumerated subjects it covers. Zero wasted words, front-loaded with the key noun phrase.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter, static informational endpoint with strong annotations and a presence of an output schema, the description is largely sufficient. It enumerates what the overview contains. One minor gap: it doesn't note that this returns static/documented content vs live data, but the 'llms.txt' reference and free annotation largely convey that.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are zero parameters, so the baseline is 4. The description correctly implies no inputs are needed (it's a static overview endpoint). Nothing more is required here.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it provides a GBLIN protocol overview for agents, listing the content areas (contracts, endpoints, prices, payment flow, field contract). The verb 'overview' and the 'for agents (llms.txt)' framing make the purpose specific. It doesn't explicitly differentiate from siblings like get_agent_economy_stats, but its scope (protocol-wide overview vs specific stats) is reasonably inferable.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies this is for agents needing to understand the protocol (llms.txt reference) before engaging with other tools. It distinguishes itself as a top-level informational resource. However, it doesn't explicitly state when to use it vs alternatives or mention any exclusions, such as 'use get_market_risk_regime for market-specific state instead'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
how_to_buy_live_attestationARead-onlyIdempotentInspect
Instructions for buying the live EIP-712-signed risk attestation over x402 ($0.003 USDC on Base) and verifying it offline.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| flow | Yes | Step-by-step x402 payment flow |
| price | Yes | |
| endpoint | Yes | Paid x402 endpoint URL |
| free_sample | No | Free integration-sample URL |
| verify_offline | No | How to verify the attestation without trusting the server |
| stable_field_contract | No | Field names guaranteed stable without versioning |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotation contradiction. The annotations declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, confirming this is a safe read/informational operation. The description adds useful context beyond annotations: it specifies the price ($0.003 USDC), the chain (Base), the mechanism (x402), and the signing standard (EIP-712), plus the offline verification aspect. This provides meaningful behavioral context for an instructional tool even though annotations already convey safety.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, tightly-packed sentence that front-loads the core purpose (instructions for buying) and includes specific details (EIP-712, x402, $0.003 USDC, Base, offline verification) without waste. Every clause earns its place. It could potentially be split for scannability, but it's efficient and information-dense.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 0 parameters, an output schema, and strong annotations, the description is reasonably complete. It explains the purpose and scope. However, it's an instructional tool with an output schema—the description could more explicitly signal the format/structure of the instructions returned (e.g., that it returns step-by-step guidance). The mention of offline verification is a good detail, but a slightly fuller description of what the returned instructions contain would improve completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are 0 parameters, and schema description coverage is 100% (no parameters). With zero parameters, the baseline is 4 per the rubric. The description itself adds value by explaining what the returned content covers (buy instructions and offline verification steps), which is relevant since this tool output is instructional rather than data.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states what the tool does: provides instructions for buying a live EIP-712-signed risk attestation over x402, including price and chain specifics. It's a how-to/informational tool rather than an action tool, and the verb 'Instructions for buying' is specific. It also adds a second function (verifying offline). It doesn't explicitly distinguish from siblings, but its purpose as instructional content is clearly distinct from data-fetching siblings like get_agent_economy_stats or get_market_risk_regime.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies this is a how-to/instructional tool to consult before purchasing an attestation. It conveys the context (buying live EIP-712 attestation on Base for $0.003 USDC) but doesn't explicitly state when to use it vs alternatives or any exclusions. The sibling tools are all data-retrieval tools, so there's an implicit contrast, but no explicit guidance on when to choose this over them.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Claim this connector by publishing a /.well-known/glama.json file on your server's domain with the following structure:
{
"$schema": "https://glama.ai/mcp/schemas/connector.json",
"maintainers": [{ "email": "your-email@example.com" }]
}The email address must match the email associated with your Glama account. Once published, Glama will automatically detect and verify the file within a few minutes.
Control your server's listing on Glama, including description and metadata
Access analytics and receive server usage reports
Get monitoring and health status updates for your server
Feature your server to boost visibility and reach more users
For users:
Full audit trail – every tool call is logged with inputs and outputs for compliance and debugging
Granular tool control – enable or disable individual tools per connector to limit what your AI agents can do
Centralized credential management – store and rotate API keys and OAuth tokens in one place
Change alerts – get notified when a connector changes its schema, adds or removes tools, or updates tool definitions, so nothing breaks silently
For server owners:
Proven adoption – public usage metrics on your listing show real-world traction and build trust with prospective users
Tool-level analytics – see which tools are being used most, helping you prioritize development and documentation
Direct user feedback – users can report issues and suggest improvements through the listing, giving you a channel you would not have otherwise
The connector status is unhealthy when Glama is unable to successfully connect to the server. This can happen for several reasons:
The server is experiencing an outage
The URL of the server is wrong
Credentials required to access the server are missing or invalid
If you are the owner of this MCP connector and would like to make modifications to the listing, including providing test credentials for accessing the server, please contact support@glama.ai.
Discussions
No comments yet. Be the first to start the discussion!
Related MCP Servers
AlicenseAqualityAmaintenancePre-trade DeFi intelligence for AI agents. 20 paid x402 endpoints, USDC on Base.Last updated23721MIT- FlicenseAquality-maintenanceTrust infrastructure for AI agents on Base. DEX Spread Oracle (live Uniswap V3 prices), on-chain escrow, insurance pool, and collective knowledge base. 7 smart contracts. Pay-per-query via x402 micropayments in USDC.Last updated6
- Flicense-qualityCmaintenancePay-per-use AI security and research tools for autonomous agents on Base, enabling honeypot detection, risk assessment, wallet analysis, and yield optimization via the x402 protocol.Last updated
- FlicenseAqualityFmaintenanceDeFi execution and agent-to-agent economy tools for AI agents — swaps, yield, transfers, policy enforcement, trust scoring, A2A jobs, and P\&L across Ethereum, Base, Arbitrum, and Polygon.Last updated311
Your Connectors
Sign in to create a connector for this server.