Model Context Protocol

Build agents that transact

QTCL is the first blockchain designed for autonomous AI agents. Post-quantum security. Flat fees. One JSON-RPC call to transact. Connect any MCP-compatible agent in 3 lines.

—

Chain Height

18s

Block Time

1 qsat

Fee / TX

MCP Tools

Agent Quickstart

Exact steps for any AI agent (Claude, GPT, Cursor, AutoGen, LangChain, CrewAI) to connect and transact.

Step 1

Connect via MCP

Add {"type":"url","url":"https://qtcl-blockchain.koyeb.app/mcp/sse"} to your MCP client config. No API key required. The server exposes 11 tools.

Step 2

Create a wallet

Call qtcl_create_wallet to get a 64-char hex address and HypΓ public key. Save the address — it is your agent's on-chain identity.

Step 3

Check balance

Call qtcl_get_balance with your address. Amounts are in QTCL (1 QTCL = 100 qsat). The flat fee is 1 qsat per transaction.

Step 4

Send a transaction

Call qtcl_send_transaction with from_address, to_address, amount (float), and optional memo (max 256 chars). Returns tx_hash immediately.

Step 5

Verify receipt

Call qtcl_get_transaction with the tx_hash to confirm inclusion. Blocks arrive every ~18 seconds. 1 confirmation = finality.

Alternative

Direct JSON-RPC

POST to /rpc with JSON-RPC 2.0 payloads. No MCP required. Methods: qtcl_getBalance, qtcl_submitTransaction, qtcl_getBlockHeight, qtcl_getBlock, qtcl_getTransaction, qtcl_getTransactions, qtcl_getQuantumMetrics, qtcl_getOracleRegistry, qtcl_getPeers, qtcl_getPythPrice, qtcl_getMempoolStats, qtcl_getHealth.

Connect any agent in 3 lines

Add to your MCP client config (Claude, Cursor, Windsurf, or any MCP-compatible framework). Zero SDK. Zero API keys.

      
// claude_desktop_config.json or .cursor/mcp.json
{
  "mcpServers": {
    "qtcl": {
      "type": "url",
      "url": "https://qtcl-blockchain.koyeb.app/mcp/sse"
    }
  }
}

Claude Claude Code Cursor Windsurf CrewAI LangChain AutoGen Any MCP Client

Available tools

qtcl_create_wallet

Create a post-quantum secured wallet. Returns a 64-char hex address and HypΓ public key.

MCP Request

{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "qtcl_create_wallet",
    "arguments": {"label": "agent-payments"}
  },
  "id": 1
}

Equivalent RPC

No direct RPC — keypair generated locally by MCP server.

qtcl_get_balance

Check confirmed and pending balance for any address. Amounts in QTCL (1 QTCL = 100 qsat).

MCP Request

{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "qtcl_get_balance",
    "arguments": {
      "address": "a1b2c3…"
    }
  },
  "id": 2
}

Equivalent RPC

{
  "jsonrpc": "2.0",
  "method": "qtcl_getBalance",
  "params": ["a1b2c3…"],
  "id": 2
}

qtcl_send_transaction

Send QTCL with flat 1 qsat fee. No gas estimation, no approval dance. Optional 256-char memo.

MCP Request

{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "qtcl_send_transaction",
    "arguments": {
      "from_address": "a1b2…",
      "to_address": "d4e5…",
      "amount": 1.5,
      "memo": "invoice-42"
    }
  },
  "id": 3
}

Equivalent RPC

{
  "jsonrpc": "2.0",
  "method": "qtcl_submitTransaction",
  "params": [{
    "from_address": "a1b2…",
    "to_address": "d4e5…",
    "amount": 1.5,
    "memo": "invoice-42",
    "signature": "…",
    "public_key": "…"
  }],
  "id": 3
}

qtcl_get_transaction

Look up any transaction by hash. Verify payment receipt, check confirmations, read memo.

MCP Request

{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "qtcl_get_transaction",
    "arguments": {
      "tx_hash": "0xabc…"
    }
  },
  "id": 4
}

Equivalent RPC

{
  "jsonrpc": "2.0",
  "method": "qtcl_getTransaction",
  "params": ["0xabc…"],
  "id": 4
}

qtcl_get_chain_info

Current chain height, latest block hash, mempool depth, oracle status, network health.

MCP Request

{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "qtcl_get_chain_info",
    "arguments": {}
  },
  "id": 5
}

Equivalent RPC

{
  "jsonrpc": "2.0",
  "method": "qtcl_getBlockHeight",
  "params": [],
  "id": 5
}
// Also: qtcl_getMempoolStats, qtcl_getHealth

qtcl_get_block

Block details by height or hash. Header, transactions, miner, reward, coherence metrics.

MCP Request

{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "qtcl_get_block",
    "arguments": {"height": 42}
  },
  "id": 6
}

Equivalent RPC

{
  "jsonrpc": "2.0",
  "method": "qtcl_getBlock",
  "params": [42],
  "id": 6
}
// Or: params: ["0xhash…"] or {"hash":"0x…"}

qtcl_get_recent_transactions

Recent transactions, optionally filtered by address. Up to 50 results sorted by time.

MCP Request

{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "qtcl_get_recent_transactions",
    "arguments": {
      "address": "a1b2…",
      "limit": 20
    }
  },
  "id": 7
}

Equivalent RPC

{
  "jsonrpc": "2.0",
  "method": "qtcl_getTransactions",
  "params": {
    "address": "a1b2…",
    "limit": 20
  },
  "id": 7
}

qtcl_get_quantum_metrics

Live W-state fidelity, entanglement witness, density matrix dimensions, oracle consensus round.

MCP Request

{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "qtcl_get_quantum_metrics",
    "arguments": {}
  },
  "id": 8
}

Equivalent RPC

{
  "jsonrpc": "2.0",
  "method": "qtcl_getQuantumMetrics",
  "params": [],
  "id": 8
}

qtcl_get_oracle_registry

List registered quantum oracles. Addresses, stake, uptime, last heartbeat. 3-of-5 BFT consensus.

MCP Request

{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "qtcl_get_oracle_registry",
    "arguments": {"limit": 10}
  },
  "id": 9
}

Equivalent RPC

{
  "jsonrpc": "2.0",
  "method": "qtcl_getOracleRegistry",
  "params": {"limit": 10},
  "id": 9
}

qtcl_get_peers

Active network peers. Node IDs, connection times, NAT types. Kademlia DHT topology.

MCP Request

{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "qtcl_get_peers",
    "arguments": {"limit": 20}
  },
  "id": 10
}

Equivalent RPC

{
  "jsonrpc": "2.0",
  "method": "qtcl_getPeers",
  "params": [20],
  "id": 10
}

qtcl_get_price

QTCL/USD price from Pyth Network oracle feed. Price, confidence interval, last update.

MCP Request

{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "qtcl_get_price",
    "arguments": {}
  },
  "id": 11
}

Equivalent RPC

{
  "jsonrpc": "2.0",
  "method": "qtcl_getPythPrice",
  "params": [],
  "id": 11
}

Why agents choose QTCL

vs Ethereum	No gas estimation. No ERC-20 approve/transferFrom. No MEV. Post-quantum signatures.
vs Solana	No program deployment. No rent. Deterministic fees. No account model complexity.
vs Lightning	No channel management. No liquidity routing. Direct transfers with memo field.
vs Stripe	No KYC. No chargebacks. No API keys. Cryptographic proof of payment. Censorship-resistant.
Unique to QTCL	Quantum oracle network, density matrix streaming, hyperbolic lattice tessellation, W-state consensus, post-quantum cryptography. No other chain has any of these.

Agent use cases

⚡

Agent-to-agent micropayments

Pay for API calls, compute cycles, and data in real-time. Flat 1 qsat fee makes sub-cent transactions viable.

🤝

Multi-agent escrow

Agent A locks QTCL. Agent B completes task. Smart release on verification. Memo field carries the contract reference.

📊

Autonomous treasury

Deterministic fee budgeting. No gas spikes. Agents can plan spend with 100% predictability.

🔐

Quantum-secured identity

Agent identity anchored to QTCL addresses with HypΓ post-quantum signatures. Survives the quantum transition.

🧾

Verifiable receipts

Transaction hash + memo = cryptographic proof of payment. No dispute resolution needed.

🌐

Cross-framework settlement

LangChain agent pays CrewAI agent. Different frameworks, same QTCL rail. MCP is the universal adapter.

MCP Server

checking...

Endpoint

/mcp/sse

Protocol

MCP 2024-11-05

Transport

SSE (Server-Sent Events)

Capability Doc

/agents/capability.json

Registered tools

qtcl_create_wallet qtcl_get_balance qtcl_send_transaction qtcl_get_transaction qtcl_get_chain_info qtcl_get_block qtcl_get_recent_transactions qtcl_get_quantum_metrics qtcl_get_oracle_registry qtcl_get_peers qtcl_get_price

Direct RPC (no MCP needed)

# Any language. Any platform. One HTTP POST. curl -X POST https://qtcl-blockchain.koyeb.app/rpc \ -H "Content-Type: application/json" \ -d '{"jsonrpc":"2.0","method":"qtcl_getBlockHeight","params":[],"id":1}'

Post-quantum cryptography

Hash

SHA3-256 (Keccak)

Signatures

Schnorr-Γ / PSL(2,R)

Wallet Encryption

HypAEAD (SHA3-256-CTR + HMAC-SHA3-256)

Key Derivation

PBKDF2-HMAC-SHA256, 600K iterations

Security Level

~256-bit classical / ~180-bit quantum

Dependencies

mpmath, numpy (engine); stdlib (wallet)

For AI Agents

# ── QTCL Agent Integration Summary ──
# This section is optimized for AI agent parsing.

MCP_ENDPOINT     = "https://qtcl-blockchain.koyeb.app/mcp/sse"
RPC_ENDPOINT     = "https://qtcl-blockchain.koyeb.app/rpc"
CAPABILITY_JSON  = "https://qtcl-blockchain.koyeb.app/agents/capability.json"
PROTOCOL         = "MCP 2024-11-05 over SSE"  # or JSON-RPC 2.0 over HTTPS
BLOCK_TIME       = 18  # seconds
FEE_PER_TX       = "1 qsat"  # flat, no gas estimation
CONFIRMATION_FINALITY = 1  # 1 block = final

# ── MCP Tools (11 total) ──
# All tools are called via method="tools/call" with params.name and params.arguments.
TOOLS = [
  {name: "qtcl_create_wallet",            rpc: "N/A (local)",        params: ["label?"]},
  {name: "qtcl_get_balance",              rpc: "qtcl_getBalance",    params: ["address"]},
  {name: "qtcl_send_transaction",         rpc: "qtcl_submitTransaction", params: ["from_address", "to_address", "amount", "memo?"]},
  {name: "qtcl_get_transaction",          rpc: "qtcl_getTransaction",  params: ["tx_hash"]},
  {name: "qtcl_get_chain_info",           rpc: "qtcl_getBlockHeight",  params: []},
  {name: "qtcl_get_block",                rpc: "qtcl_getBlock",      params: ["height?", "hash?"]},
  {name: "qtcl_get_recent_transactions",  rpc: "qtcl_getTransactions", params: ["address?", "limit?"]},
  {name: "qtcl_get_quantum_metrics",      rpc: "qtcl_getQuantumMetrics", params: []},
  {name: "qtcl_get_oracle_registry",      rpc: "qtcl_getOracleRegistry", params: ["limit?"]},
  {name: "qtcl_get_peers",                rpc: "qtcl_getPeers",      params: ["limit?"]},
  {name: "qtcl_get_price",                rpc: "qtcl_getPythPrice",  params: []}
]

# ── Cryptography ──
HASH         = "SHA3-256"
SIGNATURES   = "Schnorr-Γ / PSL(2,R)"
WALLET_ENC   = "HypAEAD (SHA3-256-CTR + HMAC-SHA3-256)"
KDF          = "PBKDF2-HMAC-SHA256, 600K iterations"
SECURITY     = "~256-bit classical / ~180-bit quantum"

# ── Economics ──
NATIVE_UNIT  = "QTCL"
BASE_UNIT    = "qsat (1 QTCL = 100 qsat)"
BLOCK_REWARD = "8.0 QTCL (miner 7.20 + treasury 0.80)"
FEE_BURN     = 0.70  # 70% of fee burned
VALIDATOR_SHARE = 0.20
COHERENCE_FUND  = 0.10

# ── Agent Use Cases ──
# 1. Agent-to-agent micropayments (API calls, compute, data)
# 2. Multi-agent escrow (lock QTCL, release on task completion)
# 3. Autonomous treasury (deterministic fee budgeting)
# 4. Verifiable receipts (tx_hash + memo = cryptographic proof)
# 5. Cross-framework settlement (LangChain → CrewAI via QTCL)
# 6. Quantum-secured identity (HypΓ addresses survive quantum transition)

# ── How to transact without MCP ──
# POST /rpc with Content-Type: application/json
# Body: {"jsonrpc":"2.0","method":"qtcl_submitTransaction","params":[tx_obj],"id":1}
# tx_obj must include: from_address, to_address, amount (float QTCL), signature, public_key
# Optional: memo (max 256 chars), nonce (auto-assigned if omitted)