AgentExec WebMCP & Base L2 Gateway
Server Details
Monetization and execution gateway for autonomous AI agents on Base Mainnet
- Status
- Healthy
- Uptime
- 65.7% over 22 days
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
- Repository
- Har50/agent1
- GitHub Stars
- 0
TDQS
Scored across 4 tools
Each tool has a clearly distinct purpose: simulation, execution, account info retrieval, and session key issuance. No overlaps or ambiguity between them.
All tool names follow a consistent verb_noun pattern (dry_run_simulation, execute_onchain_intent, get_smart_account_info, issue_session_key).
Four tools are well-scoped for this server's purpose, covering simulation, execution, account info, and key management without redundancy.
Core operations for Web3 transactions and session management are present, but lifecycle gaps exist: no update/revoke for session keys, no balance check, and no transaction status query.
Available Tools
4 toolsdry_run_simulationBRead-onlyInspect
Simulates a transaction on Tenderly without broadcasting. Returns predicted gas and balance changes. Works without an API key (rate-limited per client) unless the operator disables public simulation.
| Name | Required | Description | Default |
|---|---|---|---|
| calldata | Yes | ||
| valueWei | No | ||
| fromAddress | Yes | ||
| targetAddress | Yes | ||
| maxAllowedDrainUSD | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Goes well beyond the readOnlyHint/openWorldHint annotations by disclosing that no state is broadcast, that results are predictions of gas and balance changes, and that the tool works without an API key subject to per-client rate limits unless the operator disables public simulation. It does not cover failure behavior or what happens if the simulation reverts.
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?
Three short sentences, front-loaded with the core action and scope, then returns, then environmental constraints. No filler or repetition.
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?
With no output schema, describing the predicted gas and balance changes is useful, and the rate-limit/prerequisite note is valuable context. But a five-parameter simulation tool with zero parameter documentation — including a USD drain cap that an agent must set correctly — leaves real gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% across five parameters, so the description carries the full burden — and it provides no parameter information at all. Non-obvious inputs such as maxAllowedDrainUSD and the wei-denominated valueWei are left entirely unexplained.
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?
States a specific verb and resource ('Simulates a transaction on Tenderly') and immediately contrasts with execution ('without broadcasting'), which implicitly separates it from the sibling execute_onchain_intent. It never names that sibling explicitly, so the differentiation requires a small inference.
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 phrase 'without broadcasting' implies this is the pre-flight/validation step, but the description never says when to call it versus execute_onchain_intent or get_smart_account_info. Usage is inferable rather than stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
execute_onchain_intentADestructiveInspect
Simulates and executes a gasless, sponsored Web3 transaction on Base L2 (e.g. token swaps, transfers). Runs Tenderly dry-run safety checks automatically before broadcasting. Requires an API key.
| Name | Required | Description | Default |
|---|---|---|---|
| agentId | No | Agent identifier for session scoping. | |
| calldata | Yes | Hex-encoded transaction calldata. | |
| valueWei | No | Native token value in Wei (defaults to '0'). | |
| fromAddress | Yes | The Safe Smart Account address performing the action. | |
| sessionKeyId | No | Optional ERC-7579 session key id to enforce spend/target caps. | |
| targetAddress | Yes | Target contract or token recipient address. | |
| maxAllowedDrainUSD | No | Maximum allowable wallet drain in USD during simulation guardrail check. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare destructive=true, openWorld=true, and non-idempotent, so the safety bar is lower. The description adds genuinely new behavior beyond that: the transaction is gasless and sponsored, a Tenderly dry-run gate runs automatically before broadcast, and an API key is required for auth.
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?
Three short sentences, each carrying distinct information (what it does, the safety-check behavior, the auth requirement), with the core action front-loaded. Parenthetical examples are brief and useful; there is no filler.
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 destructive, open-world, 7-parameter tool with no output schema, the description covers action, safety gate, and auth requirement adequately. It could say more about failure/abort behavior when the dry-run guardrail trips, but it is largely complete for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so all seven parameters (including maxAllowedDrainUSD and sessionKeyId) are already documented in the schema. The description adds no parameter-level syntax or semantics beyond the schema, so the baseline 3 applies.
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?
States a specific verb+resource ('Simulates and executes a gasless, sponsored Web3 transaction on Base L2') with concrete examples (token swaps, transfers). It implicitly distinguishes itself from the dry_run_simulation sibling by noting it runs dry-run checks automatically, but never names that sibling explicitly.
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 line 'Runs Tenderly dry-run safety checks automatically before broadcasting' implicitly tells the agent it need not call dry_run_simulation first, which is useful. However, there is no explicit when-to-use/when-not guidance or named alternative to route against the three sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_smart_account_infoARead-onlyInspect
Retrieves the Agent Owner EOA address and counterfactual Safe Smart Wallet address on Base. Works without an API key.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=false, so the safe-read profile is covered. The description adds useful auth context ('works without an API key'), which is beyond the annotations, but says nothing else about behavior, e.g. whether addresses are deterministic or what happens if none exist.
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 tight sentences with nothing wasted; the return content is front-loaded and the auth note follows as supporting detail.
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?
With no input parameters and no output schema, the description carries the burden of describing the return, and it does name the two addresses returned. It stops short of explaining output format or edge cases (e.g. account not yet deployed), leaving a small gap.
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 takes no parameters, so there is no argument syntax to explain and the schema is fully self-contained. A baseline of 4 is appropriate for a zero-parameter call.
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?
Uses a specific verb ('Retrieves') plus two precisely named resources (Agent Owner EOA address and counterfactual Safe Smart Wallet address) scoped to Base. This is clearly distinguishable from the siblings (simulation, onchain intent execution, session key issuance), which all imply mutation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no indication of when to call this versus the sibling tools, nor any prerequisite or exclusion. The note 'Works without an API key' is setup context, not routing guidance, so an agent gets no help deciding when this lookup is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
issue_session_keyAInspect
Issue an ERC-7579 / ZeroDev-scoped session key (time limit, USDC spend cap, target whitelist). Requires an API key.
| Name | Required | Description | Default |
|---|---|---|---|
| target | No | ||
| agentId | Yes | ||
| maxUsdc | No | ||
| ttlHours | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare a non-read-only, non-idempotent, non-destructive, closed-world write. The description adds the key value that this is an ERC-7579/ZeroDev scoped grant and that it requires an API key. However, it omits what the issued key enables, its irreversibility or revocation, and the auth model beyond 'API key'.
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 front-loaded sentence that enumerates scope and states the prerequisite compactly, with no filler. It is terse to the point that some necessary detail is absent, but every word earns its place.
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 4-parameter mutation tool with no annotations on auth and no output schema, the description covers the concept and one prerequisite but misses parameter details, especially the required agentId, and gives no return-value or lifecycle context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It names the fields semantically via phrases ('time limit', 'USDC spend cap', 'target whitelist'), which loosely maps to ttlHours, maxUsdc, and target. But agentId (the sole required parameter) is never mentioned, and no formats, units, defaults, or ranges are given.
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?
States a specific verb ('Issue'), a precise resource ('ERC-7579 / ZeroDev-scoped session key'), and enumerates the scope constraints (time limit, USDC spend cap, target whitelist). This is clearly distinct from the read-only get_smart_account_info and the execution/simulation siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides one prerequisite ('Requires an API key') but never states when to use this tool vs alternatives. It does not indicate that a session key is a prerequisite for execute_onchain_intent, nor how it relates to dry_run_simulation, leaving sequencing to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
4 tool updates
- First observed
dry_run_simulation - First observed
execute_onchain_intent - First observed
get_smart_account_info - First observed
issue_session_key
Related MCP Connectors
Marketplace for AI agents: hire, sell, get paid in USDC on Base. Identity, jobs, reputation.
AI-native settlement rail + intelligence oracle for autonomous agents. x402, Base mainnet, 81 tools.
Pay-per-call crypto market intelligence for AI agents. USDC on Base via x402.
Machine-paid revenue intelligence and recovery for AI agents via x402 USDC on Base.
Related MCP Servers
AlicenseAqualityCmaintenancePre-trade DeFi intelligence for AI agents. 20 paid x402 endpoints, USDC on Base.2329 npm1MIT
meshledger-mcp-serverofficial
AlicenseAqualityDmaintenanceAI-to-AI economic marketplace with on-chain USDC escrow on Base L2. Agents browse skills, hire each other, manage jobs, release payments, and handle disputes via AI Judge. 15 MCP tools, reputation scoring.153MIT- AlicenseAqualityAmaintenanceAgent-to-agent marketplace where AI agents discover, invoke, and pay for services from other agents using USDC on Base L2. 72+ services, free tools, x402 micropayments.2040MIT

@1ly/mcp-serverofficial
AlicenseNot gradedqualityFmaintenanceEnables AI agents to discover, pay for, and sell APIs using crypto on Solana and Base networks, with support for automated x402 payments.65 npm3MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.