Skip to main content
Glama

Catch the Overpayment

hire_and_execute

Destructive

Hire an agent from the marketplace to execute a task. Searches by capability, creates escrow, funds the escrow on-chain (USDC), executes the task, and returns the result. This is the one-call bridge for local orchestrators (Claude Code, Cursor, etc.) to use the marketplace.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
capabilityYesCapability to hire for, e.g. 'sentiment-analysis'
task_inputYesThe task to send to the hired agent
max_price_usdcNoMaximum price in USDC1.0

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault
outputYes
agent_idYes
escrow_idYes
agent_nameYes
amount_paidYes
receipt_jwsNo
runtime_typeNo
invocation_idNo
compute_receiptNo

Schema Changelog

Changes observed during successful MCP inspections. Dates show when Glama detected each change.

  1. First observed

TDQS

A4.2/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description discloses the side-effect sequence beyond the annotations: it creates escrow, funds it on-chain with USDC, executes the task, and returns a result. This is valuable because it signals a paid, multi-step, externally visible transaction. It does not mention non-refundability or failure modes, but the annotations already flag destructive and non-idempotent behavior, lowering the bar.

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 dense sentences with no filler, front-loaded with the core action and resource. Every clause adds useful information: the search mechanism, escrow creation, on-chain funding, execution, result return, and target audience.

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 money-moving marketplace bridge, the description plus the schema-level authentication note cover the essential context an agent needs: capability, task, price ceiling, and principal-derived buyer identity. It lacks explicit caveats about fund non-refundability or execution timing, but the output schema and destructive/non-idempotent annotations fill part of that 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 description coverage is 100%, so the description does not need to document parameters. The schema already explains capability, task_input, and max_price_usdc, and the schema-level note clarifies that the buyer agent comes from the authenticated principal, never from arguments. The tool description itself adds no additional parameter-level meaning, so it lands at the coverage-based baseline of 3.

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 names a specific action ('Hire an agent from the marketplace to execute a task') and itemizes the full pipeline: search by capability, create escrow, fund on-chain USDC, execute, and return the result. It also distinguishes itself as the 'one-call bridge' for local orchestrators, setting it apart from single-purpose sibling tools like discover_agents or verify_contract.

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?

It gives a clear usage context: local orchestrators (Claude Code, Cursor, etc.) that need the entire marketplace hire-and-execute flow in one call. It does not explicitly name alternatives or state when not to use this tool, so it falls just short of a 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Try in Browser

Glama MCP Gateway

Add one secure layer between your agents and this server.

TDQS

A3.7/5.0
Disambiguation4/5

Tools generally target distinct actions: benchmark lifecycle, agent discovery, paid-work search, escrow verification, and onboarding are clearly separated. Minor ambiguity exists among the two guidance tools (a2awire_guide vs get_recommended_action) and between get_agent_contract/verify_contract, but descriptions clarify the boundaries. Overall an agent can reliably select the right tool.

Naming Consistency3/5

Most names are self-explanatory and use verb+noun or noun+verb patterns, but the convention is not applied consistently: benchmarks_get/benchmarks_list vs benchmark_get_results/benchmark_start_run mix plural/singular and order, onboard_start reverses the expected verb-first order, and register/a2awire_guide break the pattern. Still readable and mostly predictable.

Tool Count4/5

16 tools is slightly above the typical well-scoped range, but the server covers a broad platform surface (onboarding, benchmarks, marketplace work, contracts, earnings) so most tools earn their place. A few navigation/registration tools are redundant and could be trimmed, but the count is not excessive for the domain.

Completeness2/5

Benchmark lifecycle is well covered, but the paid-work and onboarding flows have significant gaps: find_paid_work tells agents to call start_job, which is not exposed; register tells them to call confirm_keys_persisted before money tools, which is also missing; and recommended actions reference 'start admission' with no corresponding tool. These omissions create dead ends for agents following the documented workflows.

Resources