This server integrates with Circle's Agent Stack to manage USDC wallets, control spending policies, send USDC, and access x402-paywalled HTTP endpoints — all via MCP tool calls.
Create wallets (circle_wallet_create): Spin up new Circle agent wallets in dev (testnet), hosted (custodial), or smart (on-chain programmable) modes.
List wallets (circle_wallet_list): Retrieve all Circle agent wallets along with their current USDC balances.
Check balance & history (circle_balance): Get the USDC balance and last 10 transactions for a specific wallet.
Set spend policies (circle_policy_set): Configure a daily USDC cap, a per-x402-call cap, and address-level allow/block lists to restrict where funds can be sent.
Send USDC (circle_transfer_usdc): Transfer USDC from a Circle wallet to any on-chain address, with an optional memo, subject to the wallet's active spend policy.
Pay x402 endpoints (circle_x402_pay): Atomically negotiate price, pay in USDC, and fetch the response from an x402-paywalled HTTP endpoint (GET or POST), with a configurable maximum price cap as a safety guard.
Provides tools for creating wallets, setting spend policies, sending USDC, and paying x402-priced endpoints through Circle's Agent Stack.
MCP server for Circle's Agent Stack. Create wallets, set spend policies, send USDC, and pay x402-priced endpoints — all from a tool call.
npx circle-agent-stack-mcpTool | What it does |
| Create an agent wallet (dev/hosted/smart) |
| List wallets with USDC balances |
| Balance + last 10 txns for a wallet |
| Set daily cap, x402 cap, allow/block lists |
| Send USDC to an on-chain address |
| Pay an x402-priced endpoint and return its response |
Related MCP server: x402-mcp
You need the Circle CLI installed and authenticated:
npm install -g @circle-fin/circle-cli
circle login
export CIRCLE_API_KEY=your_key_here{
"mcpServers": {
"circle": {
"command": "npx",
"args": ["-y", "circle-agent-stack-mcp"],
"env": {
"CIRCLE_API_KEY": "your_key_here"
}
}
}
}claude mcp add circle -- npx -y circle-agent-stack-mcpYou: Create a dev wallet called eva-treasury, set a $5 daily cap and $0.10 x402 cap,
then fetch today's BTC signal from the x402 endpoint at https://signals.example.co/btc
Claude:
→ circle_wallet_create("eva-treasury", type="dev")
{ wallet_id: "wal_abc123", address: "0x..." }
→ circle_policy_set("wal_abc123", daily_cap_usdc=5, x402_cap_usdc=0.10)
{ status: "applied" }
→ circle_x402_pay("wal_abc123", "https://signals.example.co/btc", max_price_usdc=0.10)
{ signal: "LONG", confidence: 0.72, price_paid_usdc: 0.05 }
Today's BTC signal: LONG (72% confidence). Paid $0.05.http-server.ts wraps the same tools behind an x402 paywall — agents pay per call in USDC rather than using an API key. Useful if you want to expose Circle tooling as a paid service.
CIRCLE_PAYOUT_ADDRESS=0x... npm run start:httpTo test the x402 flow locally, run the toy demo server in examples/x402-demo-server.mjs.
v0.1 shells out to the Circle CLI for all operations. This keeps auth handling out of this repo and avoids reimplementing the API client before the tool surface is validated. v0.2 will switch to direct HTTP via @circle-fin/circle-sdk.
Your Circle API key has spend authority. Always:
Set daily_cap_usdc before enabling automated payments
Start on type="dev" wallets, not mainnet
Review the allowlist before moving to production
Don't commit CIRCLE_API_KEY
circle_nanopayment_stream — streaming x402 payments for per-token billing
circle_skills_list / circle_skills_call — Circle Skills marketplace
Direct HTTP API mode (v0.2) — remove CLI dependency
Multi-chain — EURC, CCTP cross-chain transfers
Get USDC balance and the last 10 transactions for a specific wallet.
| Name | Required | Description | Default |
|---|---|---|---|
| wallet_id | Yes | Wallet ID to check balance for |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states the tool retrieves balance and transactions, implying a read operation, but does not explicitly confirm read-only nature or mention any side effects, rate limits, or authentication requirements.
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, front-loaded sentence with no unnecessary words. Every part 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 simple one-parameter tool with no output schema, the description adequately covers the what (balance and transactions) and the limit (last 10). Missing details like return format or authentication are minor given the tool's simplicity.
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% (wallet_id described as 'Wallet ID to check balance for'). The description adds 'for a specific wallet' but does not provide new parameter-level semantics beyond what the schema already offers. Baseline 3 is appropriate.
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 verb (Get), resource (USDC balance and last 10 transactions), and scope (for a specific wallet). It effectively differentiates from sibling tools like circle_transfer_usdc (transfer) and circle_wallet_list (list wallets) by specifying the exact operation.
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 usage requires a wallet_id but does not provide explicit guidance on when to use this tool versus alternatives (e.g., circle_wallet_list for all wallets). No exclusions or prerequisites are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Set spend controls on a Circle wallet: daily cap, per-x402-call cap, and address allow/block lists. Always set a daily_cap before enabling automated payments.
| Name | Required | Description | Default |
|---|---|---|---|
| wallet_id | Yes | Wallet ID to apply the policy to | |
| daily_cap_usdc | Yes | Maximum USDC spend per 24h rolling window | |
| x402_cap_usdc | Yes | Maximum USDC per single x402 micropayment | |
| allowlist | No | On-chain addresses this wallet may send to (empty = no restriction) | |
| blocklist | No | On-chain addresses this wallet may never send to |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It only states the action ('set spend controls') without disclosing behavioral traits like destructive potential, idempotency, authorization needs, or whether changes override or merge with existing policies.
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 concise sentences, front-loaded with purpose and key items. Every sentence adds value without extraneous content.
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?
Description covers the essence but lacks details on return values (no output schema) and behavior on duplicate calls (overwrite vs merge). For a 5-parameter tool with moderate complexity, it is adequate but not fully complete.
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 coverage is 100% with clear parameter descriptions. The description reiterates the parameter types (daily cap, per-call cap, lists) but adds no new meaning beyond what the schema already provides. Baseline of 3 is appropriate.
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?
Description clearly states verb 'Set' and resource 'spend controls on a Circle wallet' with specific items: daily cap, per-x402-call cap, allow/block lists. It distinguishes from sibling tools like balance, transfer, and wallet creation.
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?
Includes a usage hint ('Always set a daily_cap before enabling automated payments') but does not explicitly specify when to use this tool versus alternatives or when not to use it. Guidance is implied but not comprehensive.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Send USDC from a Circle agent wallet to an on-chain address. Confirm wallet policy allows the recipient address and the amount is within daily cap before calling.
| Name | Required | Description | Default |
|---|---|---|---|
| wallet_id | Yes | Source wallet ID | |
| to_address | Yes | Recipient on-chain address (0x...) | |
| amount_usdc | Yes | Amount in USDC (e.g. 5.00 = five dollars) | |
| memo | No | Optional transfer memo |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It correctly identifies the action as sending USDC (destructive) and mentions preconditions. However, it doesn't disclose details like fees, irreversibility, or synchronous behavior. 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, zero waste. First sentence states purpose, second gives usage instruction. Efficiently conveys key information.
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?
Given no output schema and no annotations, the description covers action and precondition but lacks detail on expected response, failure modes, or side effects. For a financial transfer, more completeness would be beneficial but the description is minimally adequate.
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% with clear descriptions for all 4 parameters. The tool description adds no additional meaning beyond the schema, so baseline 3 is appropriate.
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 verb 'Send', the resource 'USDC', and the context 'from a Circle agent wallet to an on-chain address'. It distinguishes from sibling tools (e.g., circle_balance for balance, circle_x402_pay for different payment method).
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 preconditions: confirm wallet policy allows the recipient and amount is within daily cap. This guides when to use, though it doesn't explicitly state when not to use or mention alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Create a new Circle agent wallet. Returns the wallet ID and on-chain address. Start with type='dev' for testnet exploration.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Human-readable wallet name (e.g. 'eva-treasury') | |
| type | No | Wallet type: 'dev' for testnet, 'hosted' for custodial, 'smart' for on-chain programmable | dev |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must cover behavioral traits. It states the return value (wallet ID and address), which is good, but it does not disclose whether the operation is idempotent, irreversible, requires any permissions, or has side effects on existing resources. The transparency is adequate but not thorough.
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 extremely concise with exactly two sentences. The first sentence immediately states the action and output, and the second provides a key usage recommendation. Every word earns its place with 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?
Given the tool has only two parameters, no output schema, and no annotations, the description covers the essential information: what it does, what it returns, and a practical hint. It is missing details on error handling, idempotency, or limits, but for a creation tool with low complexity, it is reasonably complete.
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 input schema has 100% description coverage for both parameters. The description adds a practical tip for the 'type' parameter ('Start with type='dev'') and an example for 'name', but these do not significantly extend the semantic meaning beyond what the schema already provides. 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.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Create a new Circle agent wallet') and the output ('Returns the wallet ID and on-chain address'). This directly distinguishes it from sibling tools like 'circle_wallet_list' (list) or 'circle_transfer_usdc' (transfer), which serve different purposes.
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 advises to 'Start with type='dev' for testnet exploration', which is a helpful usage hint. However, it does not explicitly contrast this tool with alternatives, nor does it specify when to avoid using it (e.g., if a wallet already exists). The guidance is present but limited.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all Circle agent wallets and their USDC balances.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral transparency. It only states the action and result, but does not disclose authentication needs, rate limits, whether it returns all wallets or only active ones, or any side effects.
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 concise sentence with no wasted words. It is front-loaded and easily scannable.
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?
Given the tool has zero parameters, no output schema, and a simple list operation, the description fully covers what the tool does and what it returns. No gaps are evident.
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, and schema coverage is 100%. Per guidelines, 0 parameters yields a baseline of 4. No additional parameter info is needed.
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 states 'List all Circle agent wallets and their USDC balances,' which is a specific verb+resource combination. It clearly distinguishes from sibling tools like circle_balance (single balance) and circle_transfer_usdc (transfer).
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?
No guidance is provided on when to use this tool versus alternatives. The description does not mention conditions for use, prerequisites, or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Pay an x402-priced HTTP endpoint using USDC from a Circle wallet, then return the response body. The server negotiates price, pays atomically, and fetches the content in one step. Use max_price_usdc as a safety cap — the call fails if the endpoint quotes higher.
| Name | Required | Description | Default |
|---|---|---|---|
| wallet_id | Yes | Circle wallet ID to pay from | |
| endpoint_url | Yes | The x402-priced HTTP endpoint URL to call | |
| max_price_usdc | Yes | Refuse if the endpoint quotes more than this price in USDC | |
| method | No | HTTP method for the paid request | GET |
| body | No | Request body for POST calls (JSON string) |
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 discloses that the server negotiates price, pays atomically, and fetches content in one step, and explains the failure behavior when the quote exceeds max_price_usdc. It does not mention irreversibility or timing, but is fairly transparent for a payment tool.
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 with no wasted words. The first sentence clearly states the main purpose, and the second adds a critical constraint. Concise and front-loaded.
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?
Even without an output schema, the description explains the return value (response body). It covers all necessary context for an agent to understand inputs, behavior, and failure mode. No 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 coverage is 100%, so baseline is 3. The description adds slight context (e.g., max_price_usdc as safety cap, body for POST), but mostly restates what the schema already provides.
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 uses a specific verb ('pay') and resource ('x402-priced HTTP endpoint'), and clearly distinguishes from sibling tools like circle_transfer_usdc (plain USDC transfer) and circle_balance (balance check).
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 explains when to use the tool (paying an x402 endpoint) and mentions max_price_usdc as a safety cap. It does not explicitly state when not to use it or name alternatives, but the sibling list provides implicit differentiation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.1.1circle_balancecircle_policy_setcircle_transfer_usdccircle_wallet_createcircle_wallet_listcircle_x402_payEach tool targets a distinct action: balance check, policy setting, USDC transfer, wallet creation, wallet listing, and x402 payment. There is no overlap in purpose.
All tools follow a consistent snake_case naming pattern with 'circle_' prefix and verb_noun structure (e.g., circle_balance, circle_policy_set). No style mixing.
6 tools is well-scoped for managing Circle agent wallets, covering creation, listing, balance, transfers, policy, and x402 payments. Neither too few nor too many.
Covers core wallet operations (create, list, balance, transfer, policy, x402) but lacks update or delete wallet functionality. Minor gap for full lifecycle.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Monetize any MCP server: x402 paywall, pay-per-call billing in USDC on Base, agent marketplace.
Pay-per-call DeFi and macro intel for AI agents. x402 USDC tools via streamable HTTP /api/mcp.
Agent-commerce MCP server for x402/USDC payments and affiliate splits on Base.
15 paid AI agent primitives via x402 (USDC on Base). Pay-per-call MCP server.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/kinance/circle-agent-stack-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
