← Back to Skills Marketplace
inikitin

Fortytwo MCP

by inikitin · GitHub ↗ · v1.1.0 · MIT-0
cross-platform ⚠ suspicious
180
Downloads
2
Stars
0
Active Installs
6
Versions
Install in OpenClaw
/install fortytwo-mcp
Description
Fortytwo Prime: collective multi-agent inference for high-stakes questions. ALWAYS use when the user says "Ask Fortytwo", "Ask Prime", "ask Fortytwo Prime",...
README (SKILL.md)

Fortytwo MCP

Calls Fortytwo Prime — a collective inference system where multiple independent AI agents collaborate on every question. Paid per-token via x402 escrow using USDC on Base or Monad.

Prerequisites

The script signs on-chain payments using evm_private_key environment variable. Never ask the user to paste the key into chat — it must be set via shell:

export evm_private_key="0x..."

For full wallet setup and network details, see setup.md.

Getting Started

Before the first query, or if the script fails with a setup error:

  1. Explain that Prime is available and pricing is pay-per-token
  2. Run preflight: python scripts/preflight.py
  3. If preflight fails, guide user through setup.md
  4. Note which networks preflight reports as READY — pass the correct --network to the query script

Instructions

Querying Fortytwo Prime

Run the full MCP flow via script: Run from the skill directory:

cd /path/to/skills/fortytwo-mcp
python scripts/fortytwo_query.py "your question here" --network base
  • Answer goes to stdout, diagnostics to stderr
  • Session is saved automatically to /tmp/.fortytwo_session

Follow-up queries (session reuse, no new payment)

python scripts/fortytwo_query.py "follow-up question"

Session is auto-detected from the saved file — no need to pass --session-id. Sessions live up to 90 minutes (15 min idle timeout). If the session expired, the script automatically falls through to a new payment.

Use --no-session to force a new payment. Use --session-id \x3Cuuid> to override manually.

Streaming (optional)

The bundled script does not support streaming. For incremental output on long queries, use curl with SSE directly — see streaming.md for the request format and parsing algorithm.

Key details

  • Errors are not charged. Failed requests cancel the budget reservation automatically.
  • Sessions are billing-only. Prime does not remember previous questions — include context in each query.
  • Retries are built in. The script retries up to 3 times on transient 400/502 with fresh signatures.
  • Timeout is 600s (10 minutes). On-chain settlement + multi-agent inference takes time. Run the script with a sufficient timeout — do not kill it early or set shorter limits.

How to Present the Answer

  1. Show the full answer — do not summarize unless the user explicitly asks for a summary. The user is paying.
  2. Attribute it — "Here's what Fortytwo Prime returned:"
  3. Add commentary if useful — your perspective after the full answer.
  4. Offer follow-up — "Want me to ask a follow-up?" (reuses session while budget remains).

Troubleshooting

Error Cause Fix
evm_private_key not set Env var missing export evm_private_key="0x..."
missing dependency Python packages pip install eth-account web3
low USDC balance Wallet empty Transfer USDC on Base or Monad
Transient 400/502 On-chain timing Script auto-retries; if persistent, surface to user
402 on session call Budget exhausted New payment needed (script handles this)
409/410 Session closed Script falls through to new payment
Invalid signature Wrong EIP-712 domain See payment.md — query name()/version() on-chain

References

  • setup.md — wallet setup, network config, and pricing. Read when guiding a new user through onboarding.
  • payment.md — EIP-712 signing details and common mistakes. Read when debugging signature errors or building a custom payment flow.
  • session.md — session lifecycle, error codes, and idempotency. Read when troubleshooting 402/409/410 errors on follow-up queries.
  • streaming.md — SSE streaming via progressToken. Read when the user wants incremental output on long queries (requires curl, not the bundled script).
Usage Guidance
This skill will sign on-chain payment payloads using a private EVM key and send queries to an external MCP gateway. Before installing or running it: (1) Do NOT use any high-value private key — create and fund a dedicated low-value wallet (as the docs recommend). (2) Confirm the skill registry metadata is corrected to list evm_private_key as a required credential and request provenance/homepage/audit info for the mcp gateway (https://mcp.fortytwo.network). (3) Inspect the included scripts yourself (they are present) or run them in an isolated environment. (4) Prefer using a signing flow that doesn't require placing long-term private keys in environment variables (hardware wallet or local signing service) if possible. (5) If you proceed, run the provided preflight first and verify the exact network, contract address, and gateway endpoints before funding the wallet.
Capability Analysis
Type: OpenClaw Skill Name: fortytwo-mcp Version: 1.1.0 The skill bundle provides a legitimate integration for the Fortytwo Prime multi-agent inference service, utilizing the x402 protocol for blockchain-based payments (USDC on Base/Monad). The Python scripts (`fortytwo_query.py` and `preflight.py`) handle EIP-712 message signing locally using an environment variable (`evm_private_key`) and do not exfiltrate sensitive data. The instructions in `SKILL.md` include proactive security measures, explicitly directing the AI agent never to ask the user for the private key in chat and requiring user confirmation before initiating paid calls.
Capability Assessment
Purpose & Capability
The skill's description (on-chain pay-per-token collective inference) matches the included scripts: they create x402 payment signatures, call an external MCP gateway (https://mcp.fortytwo.network/mcp), and use Base/Monad RPCs. However, the registry metadata declares no required environment variables or primary credential while the scripts require a sensitive evm_private_key env var. That omission is an incoherence: the private key is necessary for the stated payment flow but was not declared.
Instruction Scope
SKILL.md directs operators to run local Python scripts that: read evm_private_key from the environment, call public RPC endpoints, POST JSON-RPC calls to the external Fortytwo gateway, and save session state to /tmp/.fortytwo_session. The instructions do not ask the agent to read unrelated system files, but they do instruct the agent (and local operator) to handle a private key and run code that will transmit signed payment payloads and queries to a remote service — this is within the skill's purpose but materially expands the agent's runtime scope and exposes a sensitive secret if misused.
Install Mechanism
There is no install spec (instruction-only), which is lower install risk. However, the skill bundles runnable Python scripts that will be executed by the user/agent; there is no provenance or homepage beyond a claimed platform URL, and no package signing/audit. The absence of an install step reduces supply-chain risk, but executing included code still runs arbitrary network and crypto operations on the host.
Credentials
The scripts require a full EVM private key (evm_private_key), which is a highly sensitive credential appropriate for signing on-chain payments and therefore proportionate to the described pay-per-token flow — but the skill registry fails to declare this required env var or any primary credential. Requiring a raw private key in an environment variable is inherently risky; the documentation recommends a dedicated low-value wallet, but the registry omission and lack of provenance increase the risk of accidental use of high-value keys.
Persistence & Privilege
The skill does not request always:true and does not modify other skills. It persists a session id to /tmp/.fortytwo_session and reuses it for subsequent calls (max 90 minutes). This local session file is modest persistence and expected for the described billing/session flow.
How to Use
  1. Make sure OpenClaw is installed (local or Docker)
  2. Run the install command in chat: /install fortytwo-mcp
  3. After installation, invoke the skill by name or use /fortytwo-mcp
  4. Provide required inputs per the skill's parameter spec and get structured output
Version History
v1.1.0
Added • Wallet setup guide directly in the skill instructions • Automatic network selection based on where you have USDC • Session lifetime info: 90 min total, 15 min idle timeout Changed • Skill now asks for confirmation before making paid calls, except explicit “Ask Fortytwo” requests • Cleaner instructions with redundant sections removed • Query timeout raised to 10 minutes to match actual inference time • Pricing now links to the live page instead of hardcoded rates • Requires Python 3.9+
v1.0.4
- Fixed payment flow issues
v1.0.3
• Removed overly forceful wording. • Added explicit user confirmation before payment. • Rewrote the frontmatter description to match best practices.
v1.0.2
• Plugin description now explicitly declares: • Required credentials • Payment model • Dependencies • First payment requires user confirmation. • Subsequent session queries run autonomously. • Removed "doesn't object" language flagged by security review.
v1.0.1
• Improved pricing transparency and wallet security. • Added a Pricing section clarifying the pay-per-token model via x402 escrow: • The amount in the 402 challenge is a deposit ceiling, not the query price. • Unused funds are refunded automatically. • Added Wallet Setup instructions: • Connect via environment variable. • Use a dedicated low-value wallet. • Added a Preflight Check that verifies: • Key • Dependencies • Balance • Before the first query • Fixed agent behavior for direct requests: • “Ask Prime” now always executes without evaluating question complexity.
v1.0.0
- Initial release.
Metadata
Slug fortytwo-mcp
Version 1.1.0
License MIT-0
All-time Installs 0
Active Installs 0
Total Versions 6
Frequently Asked Questions

What is Fortytwo MCP?

Fortytwo Prime: collective multi-agent inference for high-stakes questions. ALWAYS use when the user says "Ask Fortytwo", "Ask Prime", "ask Fortytwo Prime",... It is an AI Agent Skill for Claude Code / OpenClaw, with 180 downloads so far.

How do I install Fortytwo MCP?

Run "/install fortytwo-mcp" in the OpenClaw or Claude Code chat to install it in one step — no extra setup required.

Is Fortytwo MCP free?

Yes, Fortytwo MCP is completely free, licensed under MIT-0. You can download, install and use it at no cost.

Which platforms does Fortytwo MCP support?

Fortytwo MCP is cross-platform and runs anywhere OpenClaw / Claude Code is available (cross-platform).

Who created Fortytwo MCP?

It is built and maintained by inikitin (@inikitin); the current version is v1.1.0.

💬 Comments