network.capability/physical-capability-cloud

Physical Capability Cloud

Discover, hire, and verify real-world physical capability through MCP.

Endpointhttps://capability.network/mcp (streamable-http)
Registry version2.19.0
Now182 tools · grade D (50) · pin ts_e716bf5550cd8f9fe2a5d377b721e650 · protocol 2025-06-18
First / last listed2026-11-14 01:13 UTC / 2026-11-14 01:13 UTC
Grade over time2026-11-14: D (50), 182 tools

Is this your server? Own a server? ToolFit hosted watch re-checks it every 24 h ($0.25 per 30 days) or 6 h ($0.60) and sends you an HMAC-signed webhook when its tools or grade change: POST https://api.youraitools.co/toolfit/v1/watch. To opt out, see About & opt-out.

Timeline

First listing · 2026-11-14 01:13 UTC
182 tools, grade D (50)

Tools: provision_api_key list_api_keys revoke_api_key setup_detect setup_generate_config setup_validate setup_register_device setup_test_job setup_status list_capability_types search_capabilities get_build_options calculate_price build_contract list_kernels get_kernel get_kernel_devices get_kernel_jobs create_kernel list_jobs get_job update_job_status list_escrows get_escrow get_escrow_chain_state get_escrow_events get_token_balance get_token_allowance get_escrow_dispute get_write_status archive_evidence get_evidence_bundle grant_evidence_access list_evidence_grants archive_encrypted_bundle get_bundle_ipfs retrieve_ipfs get_lit_conditions lit_decrypt verify_evidence_zk commit_evidence get_telemetry_stats get_active_telemetry get_job_telemetry get_telemetry_logs emit_telemetry submit_for_human_verification get_verification_assignments get_verification_status respond_to_verification dispute_verification register_capability_ip register_job_evidence_ip distribute_royalties pay_ip_royalty claim_ip_revenue get_ip_revenue get_ip_lineage get_capability_ip raise_ip_dispute get_operator_dashboard get_operator_machines get_operator_earnings get_operator_certs get_sensor_channels get_kernel_sensors get_settlement_status get_settlement_epochs onboard_machine analyze_machine_docs redeem_invite check_invite list_batches list_evidence submit_demand list_bounties claim_bounty verify_bounty get_top_demand get_bounty_leaderboard create_investment_pool stake_in_pool get_pool_earnings get_pool list_pools close_pool claim_pool convert_bounty_to_pool get_subnet_status get_subnet_miners submit_feedback report_anomaly get_unresolved_anomalies get_agent_anomalies resolve_anomaly get_anomaly_stats report_protocol_failure pcc_dht_query pcc_dht_peers approve_registration reject_registration activate_registration prove_registration list_registrations get_registration near_status near_quote near_intent near_intent_status protocol_state pcc_dht_metrics system_telemetry operator_poll_jobs operator_push_evidence operator_heartbeat operator_update_job_status pcc_submit_paid_job pcc_job_complete pcc_job_settlement pcc_submit_request pcc_list_requests pcc_get_request pcc_decompose_request pcc_publish_request pcc_get_request_dag pcc_get_request_critical_path pcc_assign_node_operator pcc_update_node_status pcc_update_request pcc_cancel_request pcc_oracle_status pcc_oracle_verify create_capability kernel_heartbeat kernel_announce_capabilities send_diagnostics send_support_message check_support_replies reply_to_support_thread pcc_capture_challenge pcc_capture_upload pcc_capture_anchor pcc_capture_status pcc_list_verdicts pcc_capture_class_registry pcc_verifier_health pcc_orchestrator_list_templates pcc_orchestrator_match_capabilities pcc_onboard_session_start pcc_onboard_session_scrape pcc_onboard_session_ingest_docs pcc_onboard_session_build_agent pcc_onboard_session_status pcc_onboard_session_live_data pcc_contributor_register pcc_contributor_list pcc_schedule_publish pcc_schedule_get pcc_schedule_evaluate pcc_training_manifest_set pcc_training_manifest_get attach_operator_channel list_operator_channels update_operator_channel delete_operator_channel test_operator_channels suggest_csd_templates get_popular_csd_templates get_operator_status propose_composition get_composition execute_composition pcc_report pcc_report_attempt save_dashboard get_dashboard search_dashboards fork_dashboard update_dashboard render_pcc_dashboard render_pcc_dashboard_ir pcc.op.capability.request_quote

Current tools (182)

provision_api_keyCALL THIS FIRST. Provisions an API key for the operator. Returns a pcc_live_* key that must be included as 'Authorization: Bearer <key>' on all subsequent requests. Accepts either email OR walletAddress. The key is shown once — save it. Without it, all other endpoints return 401.
params: email, walletAddress, name, capability
list_api_keysList all active API keys for the authenticated operator. Returns key IDs, prefixes, scopes, rate limits, usage counts, and creation/expiry timestamps. Requires a valid API key or SIWE session.
params: none
revoke_api_keyRevoke an API key permanently. The key will immediately stop working. You must own the key. Use list_api_keys to find the key ID.
params: keyId*
setup_detectAuto-detect current setup state: env vars, database, adapters, chain connectivity, storage, identity. Use this to see what's configured and what's missing before onboarding.
params: none
setup_generate_configGenerate a KERNEL_CONFIG JSON from device descriptions. Tell it what machines you have and it produces the config ready to paste into your environment.
params: devices*
setup_validateValidate a kernel config (20+ checks: JSON structure, device connectivity, adapter compatibility). Returns validation errors and warnings.
params: config*
setup_register_deviceRegister a device in the database with adapter config and capabilities. Part of Step 3 in the onboarding flow. Required: kernelId, deviceId, type and adapterType (400 missing_required_fields otherwise).
params: kernelId*, deviceId*, type*, model, adapterType*, adapterConfig, capabilities
setup_test_jobSubmit a test job for one device on a kernel (Step 4 of onboarding). The gateway runs it only for a kernel it operates in-process; for any other kernel it refuses and runs nothing. Every reply says whether the job ran and passed.
params: kernelId*, deviceId
setup_statusComprehensive setup status across 6 categories: gateway, database, adapters, chain, storage, identity. Use to confirm everything is green before going live.
params: none
list_capability_typesList all capability types registered on the network (FDM, SLA, CNC, HPLC, etc.) with metadata.
params: none
search_capabilitiesList the built-in capability type templates: each type's name, version, description, parameter count, parameter group names and a base price hint. NOTE: these describe types, not operators' offerings, and carry no assurance tiers or availability. The gateway does not read the query, so it never narrows the list. Registered capabilities of a type are listed by GET /api/capabilities?type=<type>.
params: query
get_build_optionsGet configuration options for a capability type: parameter groups, each parameter's definition, and a base price hint. It includes no assurance tiers. Use before calling calculate_price.
params: type*, selections, profileId
calculate_priceCalculate price for a capability configuration. Returns base price, tier premiums, and estimated total cost.
params: type*, selections*, profileId
build_contractBuild and submit a capability contract with on-chain milestone escrow. Returns job ID and escrow address.
params: type*, selections*, assuranceTier*, profileId
list_kernelsList all Shop Kernels on the network with status and capability types. Optionally filter by status.
params: status
get_kernelGet kernel details including full capability objects, devices, and queue.
params: kernelId*
get_kernel_devicesList all devices registered under a specific kernel, including adapter configs and device types.
params: kernelId*
get_kernel_jobsList all jobs submitted to a specific kernel, including job status and progress.
params: kernelId*
create_kernelRegister a new Shop Kernel (physical site) on the PCC network. Part of Step 2 in the onboarding flow.
params: name*, description, location, config
list_jobsList all jobs with status. Optionally filter by kernelId or status.
params: kernelId, status
get_jobGet job details including progress, evidence bundles, and milestones.
params: jobId*
update_job_statusUpdate a job's status and optional progress percentage. Used by kernels to report job progress.
params: jobId*, status*, progress
list_escrowsList escrow contracts with their milestone counts. Optionally filter by escrow status.
params: status
get_escrowGet escrow details. Pass a DB ID for database record (with milestones and disputes), or an EVM address (0x...) to read directly from the blockchain.
params: escrowId*
get_escrow_chain_stateRead full on-chain escrow state with all milestone details from the blockchain. More detailed than get_escrow for on-chain contracts.
params: address*
get_escrow_eventsGet on-chain event history for an escrow contract. Returns funding, release, dispute, and bond events.
params: address*, fromBlock
get_token_balanceRead an ERC-20 token balance for an account address from the blockchain.
params: tokenAddress*, account*
get_token_allowanceRead the ERC-20 token allowance granted by an owner to a spender from the blockchain.
params: tokenAddress*, owner*, spender*
get_escrow_disputeRead dispute state for a specific milestone from the blockchain.
params: address*, milestoneIndex*
get_write_statusCheck if on-chain write operations are enabled (requires PCC_GATEWAY_PRIVATE_KEY to be configured). Returns write status and signer address.
params: none
archive_evidenceArchive an evidence bundle to IPFS/Storacha for permanent decentralized storage. Returns the content-addressed CID.
params: bundle*
get_evidence_bundleGet an encrypted evidence bundle by its bundle ID. Returns the encrypted payload and key capsules.
params: bundleId*
grant_evidence_accessGrant a new recipient access to an encrypted evidence bundle. Creates a re-encrypted key capsule for the recipient.
params: bundleId*, recipientAddress*, accessLevel
list_evidence_grantsList all evidence access grants for an address. Returns bundles the address has been granted access to.
params: address*
archive_encrypted_bundleArchive an encrypted evidence bundle to IPFS and store the resulting CID in the database. Idempotent — returns existing CID if already archived.
params: bundleId*
get_bundle_ipfsGet IPFS CIDs for a bundle — returns the primary CID, metadata CID, and Filecoin deal ID if available.
params: bundleId*
retrieve_ipfsRetrieve raw data from IPFS by CID. Used to fetch archived evidence bundles from decentralized storage.
params: cid*
get_lit_conditionsGet Lit Protocol access conditions for a Lit-encrypted evidence bundle. Returns the conditions that gate decryption.
params: bundleId*
lit_decryptDecrypt a Lit Protocol-encrypted evidence bundle using a Lit auth signature. Returns the decrypted bundle payload.
params: bundleId*, authSig*
verify_evidence_zkVerify a ZK proof by its proof ID. Checks the proof against its verification key and public inputs.
params: proofId*
commit_evidenceCreate a Merkle commitment for an evidence bundle hash. Used as the first step in ZK proof generation for Tier 3 assurance.
params: bundleHash*
get_telemetry_statsGet aggregate pipeline telemetry statistics including phase timings, success rates, and throughput metrics across all jobs.
params: none
get_active_telemetryList currently active jobs with their current pipeline phase and telemetry status.
params: none
get_job_telemetryGet full event timeline for a specific job — all pipeline phase transitions with timings and metadata.
params: jobId*
get_telemetry_logsQuery structured logs with filters for level, source, jobId, kernelId, time range, and full-text search.
params: level, source, jobId, kernelId, search, after, before, limit
emit_telemetryManually emit a telemetry event for a job pipeline phase. Used by kernels and agents to report execution progress.
params: jobId*, phase*, status*, duration_ms, level, source, metadata
submit_for_human_verificationSubmit an evidence bundle for human verification. Selects a panel of verifiers from the network and returns assigned verifier IDs.
params: bundleHash*, photoRef*, referenceRef*, comparisonScore, verifierCount
get_verification_assignmentsGet pending verification assignments for a verifier node. Returns requests this verifier has been assigned but not yet responded to.
params: verifierId*
get_verification_statusGet verification status for a request. Returns vote tally, consensus state, dispute list, and pending response count.
params: requestId*
respond_to_verificationSubmit a verifier's verdict for a verification request. Returns consensus state after this vote.
params: requestId*, verifierId*, verdict*, notes, signature*
dispute_verificationFile a dispute against the consensus verdict. Only verifiers who submitted a response can dispute. Requires additional evidence CID.
params: requestId*, disputerId*, reason*, evidenceCid*
register_capability_ipRecord a capability as an IP asset. Story Protocol (now The DATA Foundation). These tools make no on-chain call: nothing is registered, claimed or disputed on chain. Any ipId, NFT token id or transaction hash in the reply is a placeholder, and no royalty is paid.
params: capability*, designerAddress*, designerName*, commercialRevShare, ipfsCid
register_job_evidence_ipRecord job evidence as a derivative of a capability's IP asset. Story Protocol (now The DATA Foundation). These tools make no on-chain call: nothing is registered, claimed or disputed on chain. Any id or transaction hash in the reply is a placeholder, and no royalty is paid.
params: parentIpId*, jobId*, evidenceBundleHash*, operatorAddress*, operatorName*, ipfsCid
distribute_royaltiesSet revenue splits for an IP asset among stakeholders (designer, operator, verifier, assembler, curator). Splits must sum to 100. Story Protocol (now The DATA Foundation). These tools make no on-chain call: nothing is registered, claimed or disputed on chain. No revenue is paid from these splits.
params: ipId*, splits*
pay_ip_royaltyRecord a royalty payment to an IP asset. Story Protocol (now The DATA Foundation). These tools make no on-chain call: nothing is registered, claimed or disputed on chain. No tokens move, and any transaction hash in the reply is a placeholder.
params: ipId*, amount*, payerAddress*
claim_ip_revenueClaim an IP asset's recorded revenue. Story Protocol (now The DATA Foundation). These tools make no on-chain call: nothing is registered, claimed or disputed on chain. Nothing is paid out: any amount or transaction hash in the reply is a placeholder.
params: ipId*, tokenIds
get_ip_revenueGet the revenue PCC has recorded for an IP asset. Story Protocol (now The DATA Foundation). These tools make no on-chain call: nothing is registered, claimed or disputed on chain. No revenue has been paid: any figure in the reply is a placeholder.
params: ipId*
get_ip_lineageGet the IP lineage PCC has recorded for an asset: parent capabilities and derivative job records. Story Protocol (now The DATA Foundation). These tools make no on-chain call: nothing is registered, claimed or disputed on chain.
params: ipId*
get_capability_ipGet the IP record PCC holds for a capability by its capability ID. Story Protocol (now The DATA Foundation). These tools make no on-chain call: nothing is registered, claimed or disputed on chain. Any id or transaction hash in it is a placeholder.
params: capabilityId*
raise_ip_disputeRecord an IP dispute against an asset. Provide evidence hash and reason. Story Protocol (now The DATA Foundation). These tools make no on-chain call: nothing is registered, claimed or disputed on chain.
params: ipId*, evidenceHash*, reason*
get_operator_dashboardNot available: no route answers GET /api/operator on this gateway. The operator's real kernels, devices and in-flight jobs are at GET /api/agent/me.
params: none
get_operator_machinesAnswers 501 not_available: operator machines with utilization and uptime are not recorded on this gateway. The operator's real kernels, devices and in-flight jobs are at GET /api/agent/me.
params: none
get_operator_earningsAnswers 501 not_available: operator earnings history is not recorded on this gateway. Per-job payment state is at GET /api/jobs/:jobId/execution.
params: period
get_operator_certsAnswers 501 not_available: operator certifications are not recorded on this gateway (there is no certification store; certifications typed at registration are the operator's own claim and are not checked).
params: none
get_sensor_channelsList all registered sensor channels across kernels. Returns channel descriptors with units and ranges.
params: none
get_kernel_sensorsGet sensor channels for a specific kernel. Returns live channel descriptors.
params: kernelId*
get_settlement_statusGet settlement pipeline status including pending operations count, total value queued, and smart account address.
params: none
get_settlement_epochsGet settlement epoch history showing past batch settlements with timing and operation counts.
params: none
onboard_machineRegister a new machine on the PCC network. Provide machine details to create a registration record. Include `operator` ({walletAddress, displayName, email}): without it the registration is recorded as operator 0x0000000000000000000000000000000000000000 / "Unknown", and prove cannot match it to you.
params: name*, category*, manufacturer, model, description, capabilities, operator
analyze_machine_docsAI analysis of machine documentation. Upload docs to get suggested capabilities, extracted specs, materials, and tolerances.
params: document
redeem_inviteOne-click agent onboarding with an invite code. Provisions wallet, identity, LLM access, and PCC tools in a single call.
params: inviteCode*, email*, password*, name
check_inviteValidate an invite code before redeeming it. Returns whether the code is valid and what it includes.
params: code*
list_batchesList active and completed settlement batches.
params: none
list_evidenceList encrypted evidence bundles stored in the gateway.
params: none
submit_demandRecord that you want a capability no operator offers yet. The gateway keeps the signal in memory, publishes no demand yet, and creates no bounty.
params: requesterId*, capabilityType*, description*, estimatedJobValue, estimatedFrequency, assuranceTier
list_bountiesList bounties. No gateway route creates a bounty and none is funded, so expect an empty list; no bounty pays anything.
params: status, capabilityType
claim_bountyAsk to take on a bounty as the authenticated operator. No gateway route creates a bounty, so the request finds none (409); no bounty is funded or pays anything.
params: bountyId*, operatorId*
verify_bountyRetired: the gateway answers 410 and changes no state. No caller can mark a bounty verified.
params: bountyId*, jobId*, score*
get_top_demandGet demand aggregated by capability type. The gateway doesn't publish demand yet: it answers an empty list marked `suppressed`.
params: limit
get_bounty_leaderboardGet the bounty leaderboard. No gateway route creates or verifies a bounty, so expect an empty list.
params: limit
create_investment_poolCreate an investment pool for a capability bounty.
params: capabilityType*, description*, targetAmount, currency
stake_in_poolStake USDC or credits into a capability investment pool.
params: poolId*, staker*, amount*
get_pool_earningsCheck earnings from capability investment pools for a staker address.
params: staker*
get_poolGet details of a specific investment pool including stakes, status, and revenue share terms.
params: poolId*
list_poolsList all investment pools. Optionally filter by status or capability type.
params: status, capabilityType
close_poolClose an investment pool to new stakes. Pool enters sunset phase.
params: poolId*
claim_poolOperator claims an investment pool reward after capability verification.
params: poolId*, operatorId*
convert_bounty_to_poolConvert an existing bounty into an investment pool. Allows community staking toward the bounty's capability.
params: bountyId*
get_subnet_statusThe gateway's agent bridge status: whether its in-process agents started, their names and roles, and the bridge's conversation and recent-message counts.
params: none
get_subnet_minersList the gateway's verification oracles (uma, chainlink and eigenlayer, in the order it tries them): each one's name, whether it's available, its verification count since the gateway started, and its average score.
params: none
submit_feedbackSubmit a bug report, suggestion, or general feedback about the PCC network.
params: type, message*, page
report_anomalyReport a detected anomaly — protocol failure, evidence mismatch, stuck job, or suspicious behavior. All agents on the network are notified.
params: severity*, category*, description*, targetAgentId, jobId
get_unresolved_anomaliesList all unresolved anomalies on the network. Filter by severity, category, or target agent.
params: severity, category, targetId
get_agent_anomaliesGet anomalies involving a specific agent, plus their trust impact score.
params: agentId*
resolve_anomalyMark an anomaly as resolved with a resolution note.
params: anomalyId*, resolution*
get_anomaly_statsGet aggregate anomaly statistics — total, unresolved, by severity, by category.
params: none
report_protocol_failureReport a protocol failure — when a step in the evidence/escrow/verification pipeline breaks. System may auto-recover.
params: protocol*, errorCode*, errorMessage*, involvedAgents*, jobId, recoveryAction
pcc_dht_queryQuery the DHT for capabilities matching your requirements. Returns announcements from operators whose equipment matches the type, materials, and price range you specify.
params: type, materials, maxPrice, limit
pcc_dht_peersList known DHT peers and their connection status. Shows which nodes are currently connected to the gossip network.
params: none
approve_registrationApprove a submitted machine registration. Moves it from 'submitted' to 'approved' status, enabling the operator to activate and start accepting jobs.
params: registrationId*
reject_registrationReject a machine registration with a reason. The operator can see the rejection reason and resubmit.
params: registrationId*, reason
activate_registrationActivate an approved registration, making the operator's equipment live on the network and ready to accept jobs.
params: registrationId*
prove_registrationFast-track: submit evidence that your device works and get auto-approved + activated immediately. No manual review needed. Submit a photo of test output, device health snapshot, or a full evidence bundle with completion events. If evidence meets requirements, registration jumps straight to 'active'.
params: registrationId*, evidence*
list_registrationsList all machine registrations on the network. See pending, approved, active, and rejected registrations. Public endpoint — no auth required.
params: none
get_registrationGet details of a specific machine registration by ID, including capabilities, pricing, operator info, and current status.
params: registrationId*
near_statusGet NEAR Protocol chain-abstraction integration status. Returns supported chains (near, eth, base, arbitrum, optimism, polygon), supported assets (USDC, USDT, NEAR, ETH, WBTC), and capability flags. Use this to confirm cross-chain settlement is available before requesting quotes.
params: none
near_quoteGet a cross-chain payment quote from the NEAR 1Click solver network (chaindefuser.com). Provides optimal routing and fee estimates for funding PCC escrow contracts using any source asset on any supported chain. Call near_status first to confirm available chains/assets.
params: fromChain*, fromAsset*, toChain*, toAsset*, amount*, recipient
near_intentSubmit a cross-chain payment intent to the NEAR 1Click solver network. Creates a signed intent that routes the payment atomically across chains. Call near_quote first to obtain a quoteId. Intents typically settle within 30-60 seconds — poll near_intent_status to track progress.
params: quoteId*, workflowId*, recipient
near_intent_statusCheck the settlement status of a submitted NEAR 1Click cross-chain payment intent. Statuses progress: pending → submitted → settled | failed. Returns txHash and explorerUrl when settled.
params: intentId*
protocol_stateRead the PCCProtocol root contract state: total escrow count and registry addresses. Requires PCC_PROTOCOL_ADDRESS to be configured on the gateway.
params: none
pcc_dht_metricsGet a snapshot of DHT telemetry counters and recent events. Returns message counts, peer connection stats, query/announce rates, and a list of the last 50 metric events. Use for monitoring network health.
params: none
system_telemetryRaw system state dump — actual DB rows for kernels, devices, jobs, evidence, registrations, capabilities, agent conversations, audit log. No fake numbers, no summaries.
params: none
operator_poll_jobsOperator polls jobs assigned to their kernel; status defaults to queued, and the route can filter any status. Requires operate authority for this kernel: its recorded operator identity (the caller that registered it), its proven operator wallet, or the gateway admin authority. Another identity gets 403; no credentials gets 401; an unregistered kernel gets 404 for a non-admin. Operator identity pro
params: kernelId*
operator_push_evidenceOperator pushes evidence bundle from a completed job execution. Requires decide authority for the stored job's kernel: its proven operator wallet or the gateway admin authority. A matching claimed operator key gets 403 operator_proof_required. Evidence takes decide, per DECISIONS 2026-10-04 01:25 (N31c). Evidence is posted with the kernel's proven operator wallet authority (decide). The body's ker
params: jobId*, kernelId*, evidence*
operator_heartbeatOperator sends heartbeat with capability re-announcement. Keeps the kernel alive on the network and updates its own capability rows. Requires operate authority for this kernel: its recorded operator identity (the caller that registered it), its proven operator wallet, or the gateway admin authority. Another identity gets 403; no credentials gets 401; an unregistered kernel gets 404 for a non-admin
params: kernelId*, capabilities
operator_update_job_statusOperator reports a job's status (in_progress, completed, failed). Requires operate authority for the stored job's kernel: its recorded operator identity (the caller that registered it), its proven operator wallet, or the gateway admin authority. The body's kernelId cannot choose the authorization target. Another identity gets 403; no credentials gets 401 before the job read; a job without a kernel
params: jobId*, kernelId*, status*, metadata
pcc_submit_paid_jobFast-track paid job: one call from DHT discovery to funded escrow + active scope. Auto-negotiates, quotes, creates escrow with milestones, creates execution scope. Returns jobId, scopeId, escrowId, quote with pricing adjustments, contract terms. For testnet, escrow is mock-funded automatically.
params: kernelId*, capabilityType*, parameters, paymentMethod, userAgentId*
pcc_job_completeComplete a job: gathers tool call audit trail from execution scopes, builds evidence bundle with SHA-256 hash, stores evidence, revokes scopes, and settles escrow (mock or real). This is how a job run through execution scopes is finished. A node that submitted its evidence and set status completed (operator_update_job_status) must not call it: it then answers 409 ("Job already completed or complet
params: jobId*, message
pcc_job_settlementGet a job's settlement status from its own escrow records: status (settled only when a settlement read confirms the release; reported_released when the milestone record says released but nothing confirms it; simulated for a mock escrow; awaiting_settlement, no_settlement_record, unknown or unavailable otherwise), settled, payout, paidAmount (confirmed releases only), reportedReleasedAmount, quoted
params: jobId*
pcc_submit_requestSubmit a high-level capability request in natural language. The system automatically decomposes it into a capability DAG with dependencies, timelines, and budget allocation across fabrication, design, assembly, electronics, software, logistics, and verification nodes. Returns the request with full decomposed DAG. Example: 'Build a cute animatronic plush desk robot with servo-driven animations'.
params: title*, description*, budget, deadline, urgency, currency, requesterEmail, requesterWallet
pcc_list_requestsList all capability requests with optional filtering. Shows status, decomposed DAG summary, estimated costs, and timelines.
params: status, urgency, requesterEmail
pcc_get_requestGet a capability request by ID with the full decomposed DAG — all capability nodes, their dependencies, estimated costs/hours, assigned operators, and linked bounty IDs.
params: requestId*
pcc_decompose_requestRe-trigger decomposition of an existing capability request. Overwrites the existing capability DAG with a fresh decomposition. Useful after updating the description or budget.
params: requestId*
pcc_publish_requestPublish all pending capability nodes in a request as bounties. Each node becomes a bidding opportunity for operators. Returns the list of created bounty IDs linked to each capability node.
params: requestId*
pcc_get_request_dagGet the capability DAG (directed acyclic graph) for a request as adjacency data — nodes with all fields plus explicit edges showing dependency relationships. Useful for visualization or workflow planning.
params: requestId*
pcc_get_request_critical_pathGet the critical path (longest dependency chain) for a capability request. The critical path determines the minimum calendar time to complete the request. Returns node IDs in order, the full node details, and total hours on the critical path.
params: requestId*
pcc_assign_node_operatorAssign an operator to a specific capability node within a request. The node status changes to 'assigned'. Operators claim nodes to indicate they will execute that capability.
params: requestId*, nodeId*, operatorId*
pcc_update_node_statusUpdate the status of a capability node within a request. Valid transitions: pending → bidding → assigned → in_progress → completed (or failed). When all nodes complete, the request automatically moves to completed.
params: requestId*, nodeId*, status*
pcc_update_requestUpdate a capability request's title, description, budget, deadline, urgency, or contact info. Does not re-decompose — call pcc_decompose_request afterwards if you want a fresh DAG.
params: requestId*, title, description, budget, deadline, urgency, requesterEmail, requesterWallet
pcc_cancel_requestCancel a capability request. Cancelled requests cannot be updated, decomposed, or published. This is a soft delete — the request remains visible with status 'cancelled'.
params: requestId*
pcc_oracle_statusNot served by the PCC gateway: GET /api/oracle/health returns 404 there. PCC's verification oracle runs as a separate service, and this route answers only where a deployment fronts it. Agents never call the oracle to settle a job: settlement is the gateway's step after pcc_job_complete. Where it is served, it returns the oracle's EIP-712 signing address and chain ID.
params: none
pcc_oracle_verifyNot served by the PCC gateway: POST /api/oracle/verify returns 404 there. PCC's verification oracle runs as a separate service, and this route answers only where a deployment fronts it. Agents never call it to settle a job: settlement is the gateway's step after pcc_job_complete. Where it is served, it checks that the evidence exists, its hash matches, tier requirements are met, there is no replay
params: escrowAddress*, jobId*, kernelId*, evidenceHash*, assuranceTier
create_capabilityRegister a capability instance for a kernel. Required before submitting jobs — the gateway needs at least one capability per kernel. Creates a liquid-handler, fdm, cnc-3axis, or other capability type.
params: kernelId*, type*, name, description
kernel_heartbeatSend a per-kernel heartbeat to keep the kernel marked online. Used by pcc-node daemons as an alternative to the operator relay heartbeat.
params: kernelId*, status, capabilities
kernel_announce_capabilitiesAnnounce capabilities for a kernel. NOTE: the gateway currently acknowledges this call but stores nothing, so it does not put any capability on the network. To publish a capability, use create_capability (POST /api/capabilities).
params: kernelId*, capabilities*, devices, signature
send_diagnosticsUpload an encrypted diagnostic bundle when the operator's node has problems. The bundle is encrypted client-side with a retrieval code the operator must share with support before logs can be read. Use this when the operator reports errors, crashes, or misbehavior. The pcc-node CLI runs `pcc-node logs --send` locally to collect+encrypt; prefer that path when available. This tool is for agent-driven
params: kernelId*, encrypted*, bundleHash, bundleSize, logLineCount, systemPlatform, collectedAt
send_support_messageSend an operator support message to the PCC team. Creates a new support thread or appends to the operator's existing open thread. Can optionally attach a diagnostic retrieval code (from send_diagnostics) so support staff can decrypt logs. Discord webhook fires on every new message, so expect fast response. Use this whenever the operator says something is broken, confusing, or not behaving as expec
params: kernelId*, kernelName, message*, subject, retrievalCode, systemInfo
check_support_repliesCheck for admin replies on the operator's support threads. Call this periodically or when the operator asks 'did they respond yet?'. Returns all threads for this kernel and a hasUnreadReplies boolean indicating new admin messages.
params: kernelId*
reply_to_support_threadReply to an existing support thread. Use when the operator wants to add information to a thread started earlier. Needs the threadId from check_support_replies or the original send_support_message response.
params: threadId*, message*, retrievalCode
pcc_capture_challengeIssue a fresh block-anchored CaptureNonceChallenge for a job. The operator's device must render this nonce into the captured media (QR code, audio tone, etc.) before calling pcc_capture_upload. The nonce is derived from (challengeId, latest blockHash, workOutputRoot) so captures cannot be pre-computed. Returns challengeId, 64-char hex nonce, blockNumber, maxAgeSeconds (clamped to 120).
params: jobId*, declaredClass*, requestedTtlSeconds
pcc_capture_uploadUpload a capture (photo / video / audio / sensor clip) with its CaptureManifest for G1..G6 verification. Bytes are base64-encoded inline; optional base64 C2PA manifest bytes can be supplied for CC3+ claims. The server runs the 6-gate CaptureVerifier and persists a PASS/PARTIAL/FAIL verdict. Returns {verdictId, verdict, verifiedClass, gatesPassed, gatesFailed, warnings, anchorCandidate, captureHash
params: manifest*, captureBytesBase64*, c2paManifestBase64, jobId, operatorId, challengeId, visualNonceEcho, submittedAt
pcc_capture_anchorAnchor a PASS + anchor-candidate capture verdict to CaptureClassRegistry on-chain (Base Sepolia by default). Rejects FAIL/PARTIAL verdicts. Idempotent — re-submitting the same verdictId returns the existing anchor row. Returns 202 {status:'deferred'} if CaptureClassRegistry is not yet deployed (CAPTURE_REGISTRY_ADDRESS unset).
params: verdictId*
pcc_capture_statusFetch the combined verdict + on-chain anchor view for a single capture. Mirrors the verifier's DB shape plus the anchor tx metadata (txHash, blockNumber, gasUsed, explorerUrl). Anchor is null if the verdict was never anchored.
params: verdictId*
pcc_list_verdictsList recent capture verdicts, newest first. Optionally filter by jobId. Default limit is 50, capped at 200 server-side. Returns {verdicts, count, limit, jobId}.
params: jobId, limit
pcc_capture_class_registryLook up a capture's on-chain anchor record in CaptureClassRegistry by its 32-byte captureHash. Returns the registry address, captureHash, and decoded anchor tuple (declaredClass, verifiedClass, manifestHash, submittedBy, jobId, challengeId, blockAnchor, capturedAt, attestationsRoot, attesterCount). onchain is null if the capture was never anchored. Returns 202 deferred when CaptureClassRegistry is
params: captureHash*
pcc_verifier_healthReport CaptureVerifier health: which adapters are loaded (c2pa, webauthn, appattest, playintegrity), their staleness status, in-memory challenge cache size, whether CaptureClassRegistry is deployed, and the active PCC_NETWORK. Use this to diagnose why a capture class is being rejected or degraded.
params: none
pcc_orchestrator_list_templatesList the orchestrator templates the dashboard's chat console can drive. Each entry includes slug, display_name, description, produces_kind, capability_class (physical | digital), greeting, and api_base (the route prefix that serves the six session-driver routes for that template). Public — no auth required.
params: none
pcc_orchestrator_match_capabilitiesHeuristic template matcher. Pass a free-text description of what you want to onboard (e.g. 'I run a CNC milling shop' or 'I have a Postgres database with a GraphQL endpoint') and the matcher returns all templates ranked by keyword score with a 'reason' string per match. Public — no auth required.
params: input*
pcc_onboard_session_startStart a new physical-operator onboarding session. Returns a session_id used by every subsequent /api/onboard/* call. Auth-required.
params: name*, url
pcc_onboard_session_scrapeScrape a URL into the running physical-operator onboarding session. Triggers a stealth fetch + structured extraction (machines, hours, services, certifications). Returns a small JSON summary; full extraction is appended to the session's running profile and visible via /live-data. Auth-required.
params: id*, url*
pcc_onboard_session_ingest_docsQueue documents (datasheets, SOPs, MOPs, certifications) for ingestion into a physical-operator onboarding session. Document URLs may be local:// for files dropped in the chat console or full https:// URLs. Auth-required.
params: id*, doc_urls*
pcc_onboard_session_build_agentFinalise a physical-operator onboarding session. It mints no wallet, and it can't register the operator yet: its register call sends no API key, so the gateway refuses it and this call answers 500 `build_failed` with the refusal in `message`. A retry repeats the same refused call. Auth-required.
params: id*
pcc_onboard_session_statusCoarse status snapshot for a physical-operator onboarding session: current state, 0-100 progress, scraped_count, ingested_count, last_event, publication payload (if built). Cheap — designed for polling from the chat header. Auth-required.
params: id*
pcc_onboard_session_live_dataFull event log for a physical-operator onboarding session — feeds the chat console's activity sidebar. Supports incremental polling via ?since=<unix-millis>. Returns the next cursor on every response. Auth-required.
params: id*, since
pcc_contributor_registerRegister a contributor profile binding a wallet address to a role and a published RateSchedule. Body: address (0x40hex), role (10 ContributorRole values from ADR-12 §2.1 + legacy 'designer'), scheduleHash (0x64hex of a previously published schedule), optional ipId, metadataUri, contributorNftTokenId. Returns the persisted profile (composite id is address:role:tail). Idempotent on the composite id
params: address*, role*, scheduleHash*, ipId, metadataUri, contributorNftTokenId
pcc_contributor_listList all contributor profiles for an address across roles. Returns an array of {id, address, role, scheduleHash, ipId, contributorNftTokenId, metadataUri, registeredAt}. Returns empty array when no profiles exist for the address.
params: address*
pcc_schedule_publishPublish a sealed off-chain RateSchedule. Computes scheduleHash server-side via the canonical sha256-over-canonical-JSON algorithm (matching the on-chain RateScheduleRegistry.publish() invariant). Idempotent: re-publishing the same content returns alreadyPublished:true. Returns {scheduleHash, alreadyPublished}.
params: publishedBy*, schedule*
pcc_schedule_getFetch a published RateSchedule by its content hash. Returns {schedule, publishedBy} with segments re-validated via Zod, or 404 if not found.
params: scheduleHash*
pcc_schedule_evaluateEvaluate a published RateSchedule at a moment, returning the effective bps. Inputs: scheduleHash + now (unix seconds) + optional jobValueCents (piecewise-value) + optional jobsPerDay (adoption-indexed). Returns {scheduleHash, bps, segmentKind, segmentIndex}. segmentIndex=-1 + bps=0 when no segment covers the moment (silent gap).
params: scheduleHash*, now*, jobValueCents, jobsPerDay
pcc_training_manifest_setSet (insert-or-replace) the TrainingManifest for a model IP — the dataset weight map the LicensingEngine walks when distributing payouts to a 'model-author' entry in a CompositionManifest. Dataset weightBps must sum to ≤ 10000 (gateway accepts partial mixes; on-chain enforces exact 10000). Returns {modelIpId, manifestHash}.
params: modelIpId*, baseModelIpId, datasetWeights*, methodologyHash
pcc_training_manifest_getFetch the TrainingManifest for a model IP. Returns the parsed datasets array + manifestHash + createdAt, or 404 if no manifest has been set.
params: modelIpId*
attach_operator_channelAttach a notification/dispatch channel to an operator so PCC knows how to ping them when a job lands. The operator's onboarding agent calls this AFTER the conversation that produced the channel record. Transport is a small stable enum (webhook|email|sms|voice|push|mqtt|file|manual) — vendor specifics live in the free-form `describe` field, written by the operator's agent. PCC the substrate stays n
params: slug*, label*, transport*, direction, endpoint, credentialRef, describe*, replyContract, enabled
list_operator_channelsList every channel attached to an operator. Returns the full channel records (id, transport, direction, endpoint, describe, enabled flags). Useful for an operator's onboarding agent to confirm what is wired up, and for status dashboards.
params: slug*
update_operator_channelUpdate an existing channel — toggle enabled, rewrite the describe contract, change the endpoint payload, etc. Merges into the existing record. The operator slug, id, and createdAt are immutable.
params: id*, label, direction, endpoint, credentialRef, describe, replyContract, enabled
delete_operator_channelRemove a channel from an operator. Future jobs will not dispatch to it. Use update_operator_channel with enabled=false to silence temporarily without losing the recipe in `describe`.
params: id*
test_operator_channelsFire a synthetic job at every enabled channel for an operator so the onboarding agent (and the human watching) can confirm the integration end-to-end before a real job lands. Returns per-channel dispatch results (delivered, ref, warnings).
params: slug*
suggest_csd_templatesBidirectional onboarding: the registry talks back. Describe in plain English what you are trying to set up — 'wood-fired pizza shop in SF', 'Opentrons OT-2 liquid handler', 'same-day SF courier' — and the registry returns N candidate Capability StructureDefinition (CSD) templates ranked by keyword-overlap relevance (name×3, tags×2, description×1; tie-break on usage). Empty query falls back to popu
params: q, limit, kind
get_popular_csd_templatesReturn CSDs sorted by adoption (usage-count descending). Useful for first-time operators who want to see what kind of capabilities others are publishing. Each entry includes the CSD record plus usage attribution: count, recent adopters (deduped, capped at 50), and lastUsedAt.
params: limit
get_operator_statusFour-slot substrate view for an operator: kernels, capabilities (with sla + availability), notification channels, and the per-kernel A2A agent-card URLs. Returns totals and a `missing` list naming any of the four onboarding slots that are still empty. Use this from an onboarding agent's wrap-up step to confirm 'are all four slots wired before I go live?' status is `ready` | `partial` | `unconfigur
params: slug*
propose_compositionPropose a composition — a sequenced DAG of capability instances to satisfy a multi-step outcome under a budget + assurance tier. Accepts either a flat `steps` list or an outcome chain. Returns a candidate plan ranked by `optimizeFor` (price | speed | quality) with per-step assignments. The composition is persisted for ~30 minutes (proposed status) and can be executed once via execute_composition.
params: outcomeType*, steps, outcomeChain, budgetUSD*, minAssuranceTier*, location, optimizeFor, requester, description
get_compositionRetrieve a previously-proposed composition by id. Returns 404 if unknown, 410 if the 30-minute proposal window has expired. Use this to inspect a plan before executing, or to recover a plan id after a restart.
params: id*
execute_compositionCommit a proposed composition: drives the DAG through the workflow engine, each step records a reputation outcome, the composition's reputation is finalized when the run ends. When `PCC_COMPOSE_EXECUTE_REAL=true` is set on the gateway, steps submit real jobs via JobFacade and the workflow run is durable (@pcc/workflow). When the flag is off, the NOOP runner returns synthetic success — useful in de
params: id*, idempotencyKey
pcc_reportReport a bug, friction, or dead-end you hit while using PCC. Call this the moment you get stuck and cannot recover: a 5xx (its response carries a `report_hint` with pre-filled fields), a 4xx you cannot fix from its message, the same step failing twice, or a misleading tool/description. PUBLIC — works before you provision an API key (cold agents are exactly who this is for). Persisted durably and r
params: type, summary*, detail, endpoint, method, status, errorCode, traceId, severity, agentId, logs
pcc_report_attemptReport one phase of an onboarding attempt, success or failure (attempt reporting contract v1). Send one report when each runbook phase ends, and a final report with phase "session" (with the `phases` roll-up), also when you stop early (outcome abandoned or budget_stop). Generate `sessionId` (UUID v4) once per attempt and increment `seq` with every report; a retried report with the same sessionId a
params: kind*, contract, sessionId*, seq*, phase*, outcome*, durationMs, summary, detail, logs, phases, ids, device, harness, pack, env, tokens, proposal, traceId, consent
save_dashboardSave a generated dashboard to the network so the user gets a live, shareable URL: https://capability.network/a/<slug>. Pass a `manifest` — a small declarative DashboardManifest (windows + live-data bindings + actions) conforming to the schema at https://capability.network/ui-kit/v1/manifest.schema.json; the shipped pcc-ui kit renders it identically everywhere (you compose the manifest, the kit ren
params: name*, description, manifest*, capabilityTypes, composeRefs, visibility, renderedCid
get_dashboardRecall a saved dashboard by its id or slug. Returns the full artifact (manifest + metadata). Use this to reload a dashboard the user asks for again ('open my pizza dashboard') instead of regenerating it — a saved dashboard reloads with zero regeneration. Public for public/unlisted artifacts; owner-only for private ones. Increments the load counter (a popularity signal).
params: idOrSlug*
search_dashboardsDiscover existing public dashboards before you generate a new one (recall-first — the library accrues; adopt > extend > build for UIs too). Filter by `capabilityType` (e.g. 'pizza.order'), free-text `q` over name/description/types, and `sort` by popularity or recency. Returns { entries, total, offset, limit }. Only public artifacts are listed; unlisted ones load by slug via get_dashboard but never
params: capabilityType, q, sort, offset, limit
fork_dashboardFork an existing dashboard into a new artifact you own, preserving lineage back to the original (the social remix verb). Use this to adapt a popular dashboard rather than build from scratch — e.g. fork a 'watch pizza' dashboard and raise the budget or add a receipt window via update_dashboard. Increments the source's fork counter. You can fork any public/unlisted artifact, or a private one you own
params: id*, name, visibility
update_dashboardModify a dashboard you own (owner-only). Replace the manifest or any metadata field; the version increments. Use this to edit a saved surface meaningfully — 'raise budgetUSD to 40', 'add a receipt window', 'make it public'. A replaced manifest must still conform to the schema and must not contain an API key. Only send the fields you want to change.
params: id*, name, description, manifest, capabilityTypes, composeRefs, visibility, renderedCid
render_pcc_dashboardCompose a live PCC dashboard for a physical-capability task — pass a DashboardManifest (windows + live data bindings + actions) and it renders as an interactive MCP App.
params: csd*, title*, description, api_base, theme, sections*
render_pcc_dashboard_irCompose a live PCC dashboard rendered through the closed, PCC-owned IR (read-only). Pass a DashboardManifest; it renders as an interactive MCP App via the audited closed-IR render path.
params: csd*, title*, description, api_base, theme, sections*
pcc.op.capability.request_quotePrice a configured PCC capability (typed operation). Returns the itemized quote for the given capability type + selections. Pure calculation — no funds move and nothing is created. Maps to POST /api/build/price.
params: type*, selections*, profileId, capabilityId

Entries describe changes in tool definitions. They are not statements about a server, its quality or its author. The grade measures how the tool definitions fit model providers (token cost, schema compatibility, confusable names) as scored by the ToolFit engine at the time of the listing. JSON: append .json. Opt-out: how or hello@youraitools.co.