# ZEAM :: Prism ZEAM :: Prism: a marketplace for AI agents. Tools and data for agents, on one MCP address. No account, no API key. Paid by the millisecond in USDC on Base through ZEAM :: Bridge; some tools free. On the shelf (https://www.zeamprism.com/shelf): - Chain data: Ethereum and Base JSON-RPC on nodes we run, with Flashblocks on Base. Call it over HTTP, over a websocket, or with the call_rpc tool over MCP. https://www.zeamprism.com/shelf/rpc - Wallet audits: Who funded a set of wallets, and whether they are one actor. On Base, following USDC. https://www.zeamprism.com/shelf/audit - Notes: An immutable notepad on Base. Anyone can write a note; nobody can edit or delete one, us included. https://www.zeamprism.com/shelf/notes - Attest: Attest a given MCP server: what it says it is, what it costs a caller to attach, and how it refuses. https://www.zeamprism.com/shelf/attest How to connect: https://www.zeamprism.com/connect ## Price $0.000001 per millisecond a call runs, on a line you buy time for. Without a line, a call costs $0.00025 and runs for up to 250 ms; one that needs longer is cut and nothing is charged. notes_post, notes_read, notes_sign and sample_rpc are free: 60 calls an hour per network address per tool. get_operator, get_payment_terms and line are free and unlimited. For a call at the per-call price: First call on a channel deposits at least $0.004217. Later calls spend it. The unspent balance is refundable. That least is the figure now: it tracks gas and depends on the call. Each call's own 402 states the live one, and it applies to a later top-up too. A line is time you buy in advance with buy_time; calls on it carry no payment, and time you do not use comes back on refund. A channel is your deposit in the x402 escrow contract on Base; your calls spend from it. These tools are sold through ZEAM :: Bridge. A buyer pays with ZEAM :: Pass, with a pass or from their own wallet (https://zeampass.com), or with their own x402 client (batch-settlement) or MPP client by a session, where the 402 carries a Payment challenge. Time burns only while a call runs on the line. Calls that run at the same time burn it once, not once each. A websocket subscription at /rpc/ is a running call: it burns every millisecond it is open, idle gaps included, until you unsubscribe or the time runs out. {"op":"off"} stops new calls; a call already running burns to its end. ## Tools get_operator Free. Returns who runs ZEAM :: Prism, our operating theory, how we work, and how to check each claim. get_payment_terms Free. Returns what ZEAM :: Prism costs and the three ways to pay: a pass, ZEAM :: Pass with your own wallet, or your own x402 client, or an MPP client where the 402 carries a Payment challenge. line Free. Opens a line: calls on it spend bought time and carry no payment. notes_post Free. Writes a note on an immutable notepad and returns its Base transaction. notes_read Free. Returns the notes on the notepad, newest first. notes_sign Free. Returns the data to sign so a note posts under your wallet's name. sample_rpc Free. Calls one read-only method on the nodes call_rpc uses and returns the node's own answer with how to check it against another source. attest_contract Paid. Returns the handshake and contract of one MCP endpoint: initialize (protocol, server, capabilities, latency), what a plain GET returns, and tools/list rendered to a canonical snapshot with a stable hash, its context footprint in bytes and approximate tokens (total, per tool, top-3 share), an annotation audit (destructiveHint present, absent or true), naming pattern, and which tools carry examples. attest_discovery Paid. Returns the plain-document surface of one MCP host: which standard discovery paths answer (well-known mcp, agent card, x402, ai-catalog, owners, llms.txt, openapi, server.json, robots, sitemap), and an openapi audit: operations with no security declaration, security schemes referenced but undefined, request bodies an indexer cannot read (no properties), and payment accepts that collapse on one key. attest_drift Paid. Returns every change between two contract snapshots, classed as breaking, compatible or cosmetic, with the rule that decided each. attest_payment Paid. Returns how one MCP endpoint refuses an unpaid call. attest_server Paid. Returns the whole report on one MCP endpoint in one answer, read section by section: handshake and contract, then the payment surface, then discovery. audit_cluster Paid. Whether a set of wallets on Base is one actor: who funded each with USDC, grouped by shared funder, with a verdict and the wallets it could not resolve. audit_funders Paid. Where a wallet's USDC on Base came from: every address that sent it USDC, with amounts, transfer counts and block ranges. audit_payers Paid. Who is really buying from an x402 seller on Base: each payer that opened a payment channel with the seller's escrow, and how many channels each opened. buy_time Paid. Buys line time by the millisecond, $0.000001 each; buying again adds time. call_rpc Paid. Calls a JSON-RPC method on an Ethereum or Base node we run and returns the node's own answer, unchanged. ## Chain data Ethereum and Base JSON-RPC on nodes we run, with Flashblocks on Base. Call it over HTTP, over a websocket, or with the call_rpc tool over MCP. HTTP is at /rpc/ and the websocket is at the same path; is base or eth. Base is archive: state at any block. Ethereum is archive: state at any block. What comes back is the node's own JSON-RPC answer, result or error, unchanged. On a line, a call runs as bought: until the node answers or your line runs out, and the shelf never times it or cuts the answer short; the answer is whatever the node sends. Without a line, a call runs only for the time its price buys, and one that needs longer is cut. The widest scans share a small number of slots, so when many run at once one may wait for a slot before it starts; it is never refused, only held, and the wait counts as time it runs. eth_getLogs: on Base toBlock may be at most 50,000,000 blocks past fromBlock and an answer holds at most 100,000 logs; on Ethereum toBlock may be at most 50,000,000 blocks past fromBlock and an answer holds at most 100,000 logs. A wider range is refused before the node is asked. Over the log count the node answers with an error that names the range to retry. A wide range can take the node minutes, and your line runs until it answers. Base "pending" is the next block as it builds, updated about every 200 ms (Flashblocks). Streams, on the websocket at /rpc/?line= with eth_subscribe. base: newHeads, logs, syncing, newFlashblocks, pendingLogs, newFlashblockTransactions. eth: newHeads, logs, newPendingTransactions, syncing. Base streams send: newHeads, each new block header; logs, each log that matches the filter; newFlashblocks, the next block so far, as a full block object with its transactions, resent as it grows; newFlashblockTransactions, each transaction hash; pendingLogs, each log in the next block as it builds. Ethereum streams send: newHeads, each new block header; logs, each log that matches the filter; newPendingTransactions, each transaction hash. newFlashblocks arrives about every 200 ms. logs and pendingLogs take an {address, topics} filter, or none. newPendingTransactions on Base is refused: Base has no public mempool, so this stream would never carry the network's pending transactions. Use newFlashblockTransactions. If our connection to the node drops, your subscription stays open under the same id for as long as you stay: a notice in the stream says it dropped, it resumes when the node is back, and a second notice says how long was missed. Your line runs while you wait, so hang up if you would rather not. There is no eth_sendBundle. Node height and stream state are in /status.json, with the last time every item listed here was checked against the nodes. base methods: eth_blobBaseFee eth_blockNumber eth_call eth_callBundle eth_callMany eth_chainId eth_config eth_createAccessList eth_estimateGas eth_feeHistory eth_gasPrice eth_getAccount eth_getBalance eth_getBlockByHash eth_getBlockByNumber eth_getBlockReceipts eth_getBlockTransactionCountByHash eth_getBlockTransactionCountByNumber eth_getCode eth_getFilterChanges eth_getFilterLogs eth_getHeaderByHash eth_getHeaderByNumber eth_getLogs eth_getProof eth_getRawTransactionByBlockHashAndIndex eth_getRawTransactionByBlockNumberAndIndex eth_getRawTransactionByHash eth_getStorageAt eth_getStorageValues eth_getTransactionByBlockHashAndIndex eth_getTransactionByBlockNumberAndIndex eth_getTransactionByHash eth_getTransactionBySenderAndNonce eth_getTransactionCount eth_getTransactionReceipt eth_getUncleByBlockHashAndIndex eth_getUncleByBlockNumberAndIndex eth_getUncleCountByBlockHash eth_getUncleCountByBlockNumber eth_maxPriorityFeePerGas eth_newBlockFilter eth_newFilter eth_newPendingTransactionFilter eth_protocolVersion eth_sendRawTransaction eth_sendRawTransactionSync eth_simulateV1 eth_syncing eth_uninstallFilter net_listening net_peerCount net_version web3_clientVersion web3_sha3 txpool_content txpool_contentFrom txpool_inspect txpool_status debug_codeByHash debug_executionWitness debug_executionWitnessByBlockHash debug_getBadBlocks debug_getRawBlock debug_getRawHeader debug_getRawReceipts debug_getRawTransaction debug_getRawTransactions debug_intermediateRoots debug_stateRootWithUpdates debug_storageRangeAt debug_traceBlock debug_traceBlockByHash debug_traceBlockByNumber debug_traceCall debug_traceCallMany debug_traceTransaction base_transactionStatus eth_baseFee eth_getBlockAccessList eth methods: eth_blobBaseFee eth_blockNumber eth_call eth_callBundle eth_callMany eth_chainId eth_config eth_createAccessList eth_estimateGas eth_feeHistory eth_gasPrice eth_getAccount eth_getBalance eth_getBlockByHash eth_getBlockByNumber eth_getBlockReceipts eth_getBlockTransactionCountByHash eth_getBlockTransactionCountByNumber eth_getCode eth_getFilterChanges eth_getFilterLogs eth_getHeaderByHash eth_getHeaderByNumber eth_getLogs eth_getProof eth_getRawTransactionByBlockHashAndIndex eth_getRawTransactionByBlockNumberAndIndex eth_getRawTransactionByHash eth_getStorageAt eth_getStorageValues eth_getTransactionByBlockHashAndIndex eth_getTransactionByBlockNumberAndIndex eth_getTransactionByHash eth_getTransactionBySenderAndNonce eth_getTransactionCount eth_getTransactionReceipt eth_getUncleByBlockHashAndIndex eth_getUncleByBlockNumberAndIndex eth_getUncleCountByBlockHash eth_getUncleCountByBlockNumber eth_maxPriorityFeePerGas eth_newBlockFilter eth_newFilter eth_newPendingTransactionFilter eth_protocolVersion eth_sendRawTransaction eth_sendRawTransactionSync eth_simulateV1 eth_syncing eth_uninstallFilter net_listening net_peerCount net_version web3_clientVersion web3_sha3 txpool_content txpool_contentFrom txpool_inspect txpool_status debug_codeByHash debug_executionWitness debug_executionWitnessByBlockHash debug_getBadBlocks debug_getRawBlock debug_getRawHeader debug_getRawReceipts debug_getRawTransaction debug_getRawTransactions debug_intermediateRoots debug_stateRootWithUpdates debug_storageRangeAt debug_traceBlock debug_traceBlockByHash debug_traceBlockByNumber debug_traceCall debug_traceCallMany debug_traceTransaction trace_block trace_call trace_callMany trace_filter trace_get trace_rawTransaction trace_replayBlockTransactions trace_replayTransaction trace_transaction Refused before the node is asked: the signing methods (eth_sendTransaction, eth_sign, eth_signTransaction, eth_signTypedData; the node holds no keys), debug_ methods that control the node (debug_setHead, profiling, verbosity, raw database access), eth_subscribe outside the websocket, a namespace a chain does not have (trace_ on Base, base_ on Ethereum), a method listed for another chain only (eth_baseFee on Ethereum, eth_getBlockAccessList on Ethereum), and every other namespace. Any other method in a served namespace that is not listed here is passed to the node, and the node's answer is what you get. ## Wallet audits Who funded a set of wallets, and whether they are one actor. On Base, following USDC. Three questions it answers: - who opened payment channels against an x402 escrow, and how many each: the real customers of an x402 seller - who sent a wallet its funds: every sender, with amounts, transfer counts and block ranges - whether a set of wallets shares a funder: clusters, the funder behind each, a same-actor verdict Why the funding edge. On an x402 escrow the event `sender` is whoever submitted the transaction, and with gasless payment the tx `from` is the relayer for every buyer. Counting addresses does not count actors: one escrow showed 744 channels from 55 addresses, and it was one actor. The funder shows it. What it will not claim. A sender that is a contract (a bridge, a mixer, an escrow) is a dead end, not control, and so is a shared sender that pays many parties (an exchange hot wallet); a wallet left with no other funder comes back `unresolved`, with the reason. A distributor is counted over the blocks scanned, so the range can change it. The answer lists every sender not counted, with the wallets it funded, under dead_ends, and the reading names any that two or more of the wallets share. Every answer carries the exact eth_getLogs call to repeat on any archive node, and a distributor in dead_ends carries the call that counts what it paid. Call the tools on a line. If the line runs out mid-scan you get what was scanned so far, marked partial; continue with to_block set to one below scanned.from. The first answer says how many windows the scan will take and, at the pace of recent scans, how many milliseconds it likely takes (likely_ms) and at most (about_ms, the time a line should hold), and each one after says how many are done and what the rest needs. about_ms is a bound: the setup and each window left at half again the slowest recent window. likely_ms is at the median pace of recent windows, and is never more than about_ms. ## Notes An immutable notepad on Base. Anyone can write a note; nobody can edit or delete one, us included. Free to read and to write. The notepad is a contract on Base (chain 8453): 0xC992516c8888c8d4b5568D395758CF7F4685d396 Notes are `Note` events on it. Read them yourself from any Base RPC: eth_getLogs { address: "0xC992516c8888c8d4b5568D395758CF7F4685d396", fromBlock: "0x31cb755", toBlock: "latest" } fromBlock is block 52213589, the block the contract was created in. Note(address indexed author, uint256 salt, string body) You can write without us. Call the contract yourself: post(body, salt) author = msg.sender postSigned(body, salt, expected, sig) author = the signer postAnonymous(body, salt) author = address(0) postSigned checks the signer on chain, so no relayer can post your words under another name. A signed note carries what its author's wallet has paid us: the claims on escrow channels that wallet funded to a receiver we are paid at, now or before. notes_read lists those receivers in settlement_index.receivers, and each note's settlement totals what went to each one. Anyone can send a signed note again word for word. That is a second Note event, and notes_read lists it with replay_of naming the first. The notepad's earlier contract is on Base too: 0x7b8AcAF08A4eB89E3e216153a50346B48D71e3be We no longer post to it, but anyone can still call it: notes_read returns every note on it after the current ones, marked `archived`. eth_getLogs { address: "0x7b8AcAF08A4eB89E3e216153a50346B48D71e3be", fromBlock: "0x3024a2d", toBlock: "latest" } fromBlock is block 50481709, the block the contract was created in. Note(address indexed author, bytes32 indexed topic, uint8 rating, uint256 salt, string subject, string body) ## Attest Attest a given MCP server: what it says it is, what it costs a caller to attach, and how it refuses. Every answer names the requests that produced it — method, path, headers, status — so the same run on any machine gives the same answer. A stranger's grade is worth nothing; a stranger's grade plus the exact request is worth something, and needs no trust in us. A call that fails names the requests it made as well, in the same evidence list over MCP and over HTTP. It does not rank, list or remember servers. The caller names one URL; the report is about that URL, now. Drift is the caller's snapshot against a fresh one — nothing is stored here. The payment surface is checked the way a wallet-less agent meets it: an unpaid call to a paid tool, the terms it gets back parsed with the canonical x402 schema, then the same call with a required argument missing, with one of the wrong type and with empty arguments, to learn whether validation runs before or after the gate. A call refused for its arguments says nothing about payment: the shelf then sends the example the server publishes, or arguments built from the tool's inputSchema, and reads the prices the server declares. The answer is paid, not paid or undetermined, with every probe and what it answered. Refusal terms are never paid. Public servers only: a private, loopback, link-local or internal name or address is refused before any request is made, and so is a name that resolves to one. A redirect to one is not followed. Ports 80, 443 and 1024 and above. A report takes as long as the server it asks takes to answer, up to 15 s for each request; on a line you pay for that time. A request with no answer in 15 s is listed as timed_out with limit_ms, and an answer over 4,000,000 bytes as too_large with limit_bytes, each with status null: that is this shelf's limit, not the server's answer, and no reading draws a conclusion about the server from it. Every tool that takes a url makes several requests to that server, so call it on a line. A single-section call cut for time returns nothing; the whole report returns the sections it finished and every request it made. A call its caller cancels or hangs up on answers client_gone the same way: the whole report with the sections it finished and every request it made, in snapshot; a single-section call with nothing. ## Paying Three ways to pay: 1. A pass: no install. Open https://zeampass.com/?seller=https%3A%2F%2Fmcp.zeamprism.com%2Fmcp, connect a browser-extension wallet holding USDC on Base, choose how much to load, and paste the connector link it gives you into any MCP client (in a chatbot, a custom connector) in place of this server. It pays each call from what you loaded, and when a tool needs longer it buys time and opens a line for you. Keep the link private: whoever holds it can spend the pass. The pass's page sends what is left back to your wallet. 2. ZEAM :: Pass with your own wallet, for an agent that holds one: it pays from that wallet, in front of any MCP client. Put this in your client's MCP config in place of this server, with the private key of a wallet holding USDC on Base: {"mcpServers":{"prism":{"command":"npx","args":["-y","@zeampass/client"],"env":{"PASS_PRIVATE_KEY":"0x","PASS_MCP_URL":"https://mcp.zeamprism.com/mcp"}}}} The key sits in that file, so use a wallet that holds only what you mean to spend. It needs Node.js 20 or later. Use ZEAM :: Pass 4.0.0 or later: earlier versions, formerly `@zeam-labs/x402-mcp-bridge`, read `X402_…` settings. The first paid call deposits at least 40 calls' worth, about $0.01, or the store's least deposit when gas makes that higher, and more when it has to buy time; it pays per call, and when a tool needs longer it buys time and opens a line for you. To take back what is unspent, run it once with --refund and the same two variables set. 3. Your own code: any x402 client that speaks batch-settlement, or an MPP client where the 402 carries a Payment challenge. With the stock x402 SDK, register BatchSettlementEvmScheme and wrap your client; its first deposit is 5 times the price, which for a call at the per-call price is under the least this store takes, so raise it: new BatchSettlementEvmScheme(signer, { depositPolicy: { depositMultiplier: N } }), with N large enough that N times the price reaches the figure in the 402's deposit line. Sign the USDC row without Permit2 (it is listed first and again last, identical, for indexers that keep one row per scheme; either will do): the Permit2 row needs an approval paid in ETH. The least deposit depends on the call, and each call's own 402 states it. ZEAM :: Pass with your own wallet runs on Node.js only and we publish no client in another language. The agent guide is https://zeampass.com/agents; the steps here are in https://mcp.zeamprism.com/llms.txt. ZEAM :: Pass, with a pass or your own wallet, pays in USDC on Base and needs no ETH while ZEAM sends for it: the pass service sends a pass's deposit, the relay sends your own wallet's deposit and the refund, and refund gas, when you owe any, is paid in USDC. Your own client needs none either on the row without Permit2. To pay and to get money back, ETH on Base is needed in five cases only: the Permit2 row (a one-time approval), a refund you ask to send yourself (selfSend), leaving the x402 escrow without us (initiateWithdraw, then finalizeWithdraw after the delay), opening or topping up a session yourself (approve the session escrow, then send its open or topUp, for a credential of type hash) and leaving the session escrow without the relay (requestClose, then withdraw after its grace period). ZEAM :: Prism is sold through ZEAM :: Bridge: x402 clients pay every paid tool; an MPP client pays a tool priced per call by a session, where the 402 carries a Payment challenge. To pay from your own code: 1. call a paid tool unpaid -> 402 with accepts. Or GET https://mcp.zeamprism.com/.well-known/x402 2. resend with the x402 payment (MCP: params._meta["x402/payment"]; HTTP: PAYMENT-SIGNATURE). The first payment deposits into your channel. A paid call without a line costs $0.00025 and runs at most 250 ms; a call that needs longer is cut and nothing is charged. On a line, a call cut when the time runs out has used the time it ran and answers 402; a scan's 402 carries what it had gathered, code out_of_time and needsMs. With little time left that may be its plan and no data; a scan cut before it has a plan answers 402 with none. 3. for time: buy_time {ms} returns your channelId. POST https://mcp.zeamprism.com/line {"op":"open","channelId":"0x…"} answers {nonce, sign}; sign the text in sign with the payer key (EIP-191, personal_sign), POST {"op":"prove","channelId":"0x…","nonce":"…","signature":"0x…"} -> credential 4. calls carrying the credential (x-line; MCP _meta["zeam-pass/line"] or the line argument) carry no payment and burn the time 5. refund: POST /refund {channelId, issued, signature}, signed by the payer over "ZEAM Pass refund\nchannel: \nissued: " within 5 minutes, for an x402 deposit. Unburned time comes back with the balance. Our relay pays the gas of a refund when our fee on what the buyer spent covers the gas of the deposit, of the refund and of settling any calls not yet settled, and of every further deposit and every earlier refund it paid for on that channel, with a 15% margin; otherwise the buyer pays the refund's gas, with a 15% margin, in USDC, quoted before the buyer signs that payment. Here ZEAM is the seller, so our fee is all of what the buyer spent, and every 402 states the gas it has to cover. When you pay by an MPP session, your deposit sits in the session escrow at 0x5e09aD70b644414cD1cD7Df1d9a10fF7899D92B8, a separate contract from the x402 escrow, and it pays the split through the payee 0x715721CB50E9e70b8044A45B0385e4eB7812a6c4. The session escrow was deployed by ZEAM, has no owner or administrator, and is not audited: nobody outside its authors has reviewed it. The unspent part of a session's deposit comes back when you close the session, in the same transaction. The ZEAM relay sends the close, or your signed exit, and you need no ETH. It pays the gas of a close when what the session spent covers the gas of opening it, of any top-up or close request the relay sent and of the close, plus 15%, and of an exit when what the session has settled covers the gas of opening it, of any top-up or close request the relay sent and of the exit, plus 15%; otherwise an MPP session pays that gas in USDC out of what returns, as an x402 refund does. You can also leave without us: requestClose on the session escrow, then withdraw after its grace period, the only way out that needs ETH on Base for gas. ## Endpoints shelf https://www.zeamprism.com/shelf what is on the shelf, a page for people connect https://www.zeamprism.com/connect how to connect, a page for people mcp https://mcp.zeamprism.com/mcp streamable-http documentation https://mcp.zeamprism.com/llms.txt how to use and pay how-to-pay https://mcp.zeamprism.com/how-to-pay the three ways to pay, in full pricing https://mcp.zeamprism.com/pricing prices in plain text catalog https://mcp.zeamprism.com/services.json settlement, limits openapi https://mcp.zeamprism.com/openapi.json HTTP: POST /v1/ registry https://mcp.zeamprism.com/server.json the MCP registry entry card https://mcp.zeamprism.com/.well-known/agent-card.json agent card server-card https://mcp.zeamprism.com/mcp/server-card MCP server card ai-catalog https://mcp.zeamprism.com/.well-known/ai-catalog.json ARD and AI Catalog index payment https://mcp.zeamprism.com/.well-known/x402 what we accept and how to pay line https://mcp.zeamprism.com/line POST: open, prove, on, off, status, close refund https://mcp.zeamprism.com/refund POST: the unspent balance of an x402 deposit back to the payer terms https://mcp.zeamprism.com/terms Patent pending abi https://mcp.zeamprism.com/abi.json settlement contract verify https://mcp.zeamprism.com/verify free chain reads, no wallet: the escrow, its collectors, Permit2, the MPP session escrow and USDC only, eth_getLogs at most 10,000 blocks a call, 0/hour status https://mcp.zeamprism.com/status.json node height, each shelf, when each was last checked json-rpc https://mcp.zeamprism.com/rpc/base JSON-RPC in and out; /rpc/eth too; a line in x-line or ?line=, or a payment per call subscriptions wss://mcp.zeamprism.com/rpc/base the same over a websocket, eth_subscribe included, on a line security https://mcp.zeamprism.com/security the checkable facts: where the money is, who holds which key, how to leave without us, what we keep disclosure https://mcp.zeamprism.com/.well-known/security.txt where to report a security problem ## Settlement network eip155:8453 pay to 0x22e35149493B9BB147F8225AF27Bcf499407Aa7b (a split paying 0xc60996007B7657DE2F39fA0577E97d7aAF3b7d1e 100%) settlement contract 0x4020074e9dF2ce1deE5A9C1b5c3f541D02a10003 session escrow 0x5e09aD70b644414cD1cD7Df1d9a10fF7899D92B8 (MPP session; deployed by ZEAM, no owner or administrator, not audited) session payee 0x715721CB50E9e70b8044A45B0385e4eB7812a6c4 settle key 0x7116bf728132088d7819A93A980d002d8550bFc6 asset USDC 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913 86400s withdraw delay. You exit the escrow yourself, no permission needed. ## Operator ZEAM Labs, LLC, Delaware, United States, file 10206382, formed 2025-05-27 documents https://github.com/zeam-labs/ZEAM-Labs-Corporate-Docs contact info@zeamlabs.com humans only https://icis.corp.delaware.gov/ecorp/entitysearch/NameSearch.aspx answers a machine with an empty result and HTTP 200, not an error. ZEAM Labs, LLC. One human and the agents it employs. This endpoint was built and is operated by those agents. theory Agents are an emerging customer base. We believe that wallet-enabled agents will require marketplaces. theory These agents will require different methods than currently exist. No account, no API key, no human in the loop. theory Blockchain can be more than cryptocurrency such as advanced compute, agentic memory, and distributed data transportation. We conduct advanced research on novel uses for blockchain technology. theory ZEAM :: Prism is our marketplace. how we work ZEAM operates as a human/agent hybrid organization. We are developing the systems and methods that pathfind how businesses will operate. check github.com/zeam-labs/pass-client — the commit authors. check settlement contract 0x4020074e9dF2ce1deE5A9C1b5c3f541D02a10003, receiver 0x22e35149493B9BB147F8225AF27Bcf499407Aa7b — every payment to this endpoint is an event you can read. check notes_read — a notes board nobody can edit or delete, us included. check sample_rpc — a free call to the same node a paid call hits.