Build any AI agent in 30 seconds

LangChain Agent

Python LangChain agent with live prices, web search, on-chain memory, and hallucination checks.

On-Chain Agent (Base + ETH)

Autonomous agent that monitors prices, simulates TXs, and executes on Base mainnet.

MCP Server (Cursor / Claude)

TypeScript MCP server that exposes x711 tools to Cursor, Claude Code, and Windsurf.

CrewAI Multi-Agent Swarm

4-agent CrewAI crew with shared x711 tools and collective memory.

Crypto Trading Signal Agent

DeFi data monitor that generates buy/sell signals and alerts on high-confidence setups.

Pre-wired in every prompt

✓web_search — live web

✓price_feed — ETH, BTC, SOL

✓hive_read/write — memory

✓tx_simulate + broadcast

✓hallucination pills

✓auto-register on first run

✓free tier — no card needed

Copy this prompt

Build me a production LangChain AI agent in Python.

The agent should:
1. Answer questions about crypto prices, DeFi protocols, and on-chain activity
2. Search the web for real-time context
3. Store important findings in collective agent memory for future runs
4. Verify every token address with a hallucination pre-flight before any on-chain reference
5. Run as a ReAct agent with structured tool output

Install the x711 SDK: pip install x711
It auto-registers your agent on first run — no manual API key setup needed.

Tools (implement each as a @tool decorated function):

from x711 import X711
x711_client = X711()  # reads X711_API_KEY env var; auto-registers if missing

@tool
def web_search(query: str) -> str:
    """Search the web for current information."""
    return x711_client.call("web_search", {"query": query})

@tool
def price_feed(symbols: str) -> str:
    """Get live crypto prices. symbols = comma-separated e.g. 'ETH,BTC,SOL'"""
    return x711_client.call("price_feed", {"query": symbols})

@tool
def hive_memory_read(query: str) -> str:
    """Read from collective agent memory — insights stored by this agent and others."""
    return x711_client.call("hive_read", {"query": query})

@tool
def hive_memory_write(content: str) -> str:
    """Save an insight to collective agent memory for future runs."""
    return x711_client.call("hive_write", {"content": content, "namespace": "langchain-agent"})

@tool
def hallucination_check(claim: str, chain: str = "base") -> str:
    """MANDATORY: Verify token addresses and on-chain claims before use."""
    return x711_client.call("pill_check", {"claim": claim, "chain": chain})

Use langchain, langchain-openai, x711. Requires OPENAI_API_KEY + X711_API_KEY (auto-set on first run).
Deliverables: agent.py, tools.py, .env.example, requirements.txt, README with one-command setup.

Build me a production-ready autonomous on-chain AI agent in Python.

Capabilities:
1. Real-time price monitoring for ETH, BTC, SOL, and Base ecosystem tokens
2. Smart contract interaction on Base mainnet — simulate transactions, then broadcast if safe
3. Mandatory hallucination checks on ALL token addresses before any transaction
4. Collective memory — write insights after every run, read from the shared pool at startup
5. Async execution with configurable thresholds and graceful error handling

Install the x711 SDK: pip install x711
It auto-registers your agent and manages your API key.

from x711 import X711
x = X711()  # auto-registers on first run, writes X711_API_KEY to .env

# Core tool calls — all go through x711
prices   = x.call("price_feed",    {"query": "ETH,BTC,SOL,USDC"})
simulate = x.call("tx_simulate",   {"chain": "base", "to": "0x...", "data": "0x..."})
broadcast= x.call("tx_broadcast",  {"chain": "base", "signed_tx": "0x..."})
memory   = x.call("hive_read",     {"query": "base defi signals"})
x.call("hive_write", {"content": "insight...", "namespace": "onchain-agent"})

# MANDATORY before any TX — abort if hallucination_risk is high or critical
pill     = x.call("pill_check", {"claim": "0x<token_address>", "chain": "base"})
if pill.get("hallucination_risk") in ["high", "critical"]:
    raise ValueError(f"Hallucination detected: {pill['correction']}")

Stack: Python 3.11+, asyncio, x711, python-dotenv.
Deliverables: main.py, .env.example, README with one-command setup, working demo run.

Build me a Model Context Protocol (MCP) server in TypeScript that exposes x711 tools to any AI editor.

The MCP server should expose these tools to the AI:
- web_search(query: string) — live web search
- price_feed(symbols: string) — real-time crypto prices (ETH, BTC, SOL, etc.)
- hive_read(query: string) — read from collective agent memory across all x711 agents
- pill_check(claim: string, chain: string) — hallucination pre-flight before any on-chain claim
- code_sandbox(code: string, language: string) — execute code securely

Install the x711 SDK: npm install x711
It handles auth and auto-registration.

import { X711 } from 'x711';
const x711 = new X711(); // reads X711_API_KEY env var; auto-registers if missing

Each tool should call x711.call(toolName, params) and return the result as a string.

Include proper MCP tool descriptions so the AI knows when to use each tool.

MCP Config for the README (Claude Desktop + Cursor):
{"mcpServers":{"x711":{"command":"node","args":["dist/index.js"],"env":{"X711_API_KEY":"YOUR_KEY"}}}}

Stack: TypeScript, @modelcontextprotocol/sdk, x711, Node 20+, esbuild for single-file bundling.
Deliverables: src/index.ts, package.json, tsconfig.json, README with Cursor install deeplink.

Build me a production CrewAI multi-agent system in Python with a 4-agent crew.

Agents:
1. Scout — web research and trend discovery
2. Analyst — on-chain data analysis and price interpretation
3. Writer — drafts reports, stores key findings in collective memory
4. Coordinator — orchestrates the others, validates findings, handles errors

Install the SDK: pip install x711 crewai
The x711 SDK auto-registers your agent on first run.

Shared tool helper (all 4 agents use this):
from x711 import X711
x711_client = X711()

def x711_tool(name: str, **params):
    return x711_client.call(name, params)

Tool wrappers for CrewAI @tool decoration:
- web_search(query)     → x711_tool("web_search", query=query)
- price_feed(symbols)   → x711_tool("price_feed", query=symbols)
- hive_read(query)      → x711_tool("hive_read", query=query)
- hive_write(content)   → x711_tool("hive_write", content=content, namespace="crewai")
- onchain_insight(protocol, chain) → x711_tool("onchain_insight", protocol=protocol, chain=chain)
- pill_check(claim)     → x711_tool("pill_check", claim=claim, chain="base")

Each agent should have a clear role, goal, and backstory. The Coordinator runs last and synthesizes output.

Stack: Python 3.11+, crewai, x711. Requires OPENAI_API_KEY.
Deliverables: crew.py, tools.py, agents.py, .env.example, requirements.txt, README.

Build me a crypto trading signal agent in Python that runs continuously.

What it does every 5 minutes:
1. Fetches live prices for ETH, SOL, BTC, and USDC
2. Pulls DeFiLlama TVL trends and DexScreener pool data via data_retrieval
3. Generates buy/sell/hold signals with a confidence score (0-100)
4. Verifies ALL token addresses with hallucination pre-flight before any reference
5. Logs high-confidence signals (>75) to collective agent memory for cross-agent learning
6. Sends email alerts on signals above the threshold

Install the SDK: pip install x711
from x711 import X711
x = X711()  # auto-registers, no setup needed

Tool calls:
prices   = x.call("price_feed", {"query": "ETH,BTC,SOL,USDC"})
tvl_data = x.call("data_retrieval", {"url": "https://api.llama.fi/protocols"})
memory   = x.call("hive_read", {"query": "trading signals ETH momentum"})
x.call("hive_write", {"content": f"ETH signal: {signal}", "namespace": "trading"})
x.call("email_send", {"to": ALERT_EMAIL, "subject": f"Signal: {signal}", "body": details})

# Before referencing any token address:
pill = x.call("pill_check", {"claim": token_address, "chain": "base"})
# abort if pill["hallucination_risk"] in ["high", "critical"]

Stack: Python 3.11+, asyncio, schedule, x711.
Deliverables: main.py, signals.py, config.py (thresholds), .env.example, requirements.txt, README.

Replit Agent ↗ Cursor ↗ + Rules file

How it works

The AI reads the prompt and builds your project. On first run it calls POST /api/onboard automatically — your agent gets registered and an API key is written to .env. No manual setup.

Free tier: 10 calls/day, no credit card. Get more: top up with USDC (first deposit +25% bonus) or check for a radio drop — scarce free credits, limited slots.

Want x711 pre-wired in every project without copy-pasting? Add one rules file →

Build any AI agentin 30 seconds

Build any AI agent
in 30 seconds