Physical Capability Cloud MCP server
Commit Nov 14, 2026Enables AI agents to discover, negotiate, and book real-world physical services like 3D printing and lab automation through a verifiable protocol.
Also known as LamaSu/physical-capability-cloud, physical-capability-cloud
- Stars
- 3
- Tools
- —
- Downloads, 30 days
- —
- Latest version
- 2.19.0
- Last commit
- Nov 14, 2026
- License
- Apache-2.0
What is Physical Capability Cloud MCP?
Physical Capability Cloud enables AI agents to discover, negotiate, and book real-world physical services like 3D printing and lab automation through a verifiable protocol.
Summary generated from the project's README
About Physical Capability Cloud MCP server
Physical Capability Cloud provides an open protocol for turning physical hardware into programmable services. It allows AI agents and developers to discover, negotiate, and book real-world tasks such as 3D printing, CNC milling, and lab automation. The system functions as a substrate where operators run hardware and customers contract work over HTTP, using on-chain escrow to protect both parties during the execution phase.
Users can connect an AI agent by fetching a JSON schema package or deploy an MCP server for use with tools like Claude Code. Operators can integrate machines using a Python node that auto-discovers hardware and provisions API keys. The protocol ensures trust through various assurance tiers, ranging from simple self-attested device snapshots to sovereign ZK-anchored proofs for regulated industries like medical or aerospace manufacturing. Settlement occurs automatically when cryptographic evidence meets the agreed contract requirements.
What you can do with it
- 1Automated 3D printing procurementAn AI agent can find an idle FDM printer, lock funds in escrow, and monitor the print process via streaming evidence.
- 2Remote laboratory analysisA developer can use an agent to queue chemical compound analysis at a regulated lab located in a different country.
- 3Complex multi-step manufacturingAn agent can decompose a large manufacturing request into individual steps and hire different providers for each part of the process.
Written from the project's README. Every use case is checked against a quote from it.
How to install Physical Capability Cloud MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall Physical Capability Cloud MCP in Claude Code
$ claude mcp add --transport http physical-capability-cloud https://capability.network/mcpInstall Physical Capability Cloud MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"physical-capability-cloud": {
"url": "https://capability.network/mcp"
}
}
}Install Physical Capability Cloud MCP in VS Code
.vscode/mcp.json
{
"servers": {
"physical-capability-cloud": {
"type": "http",
"url": "https://capability.network/mcp"
}
}
}Install Physical Capability Cloud MCP in VS Code CLI
$ code --add-mcp '{"name":"physical-capability-cloud","type":"http","url":"https://capability.network/mcp"}'Install Physical Capability Cloud MCP in Codex
$ codex mcp add physical-capability-cloud --url https://capability.network/mcpInstall Physical Capability Cloud MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.physical-capability-cloud] url = "https://capability.network/mcp"
Install Physical Capability Cloud MCP in Gemini CLI
$ gemini mcp add -s user --transport http physical-capability-cloud https://capability.network/mcpInstall Physical Capability Cloud MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"physical-capability-cloud": {
"url": "https://capability.network/mcp",
"type": "http"
}
}
}Configuration
PCC_URL
| Name | Description | |
|---|---|---|
| PCC_URL | — |
Automated checks
Ran Nov 14, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachablelamasu/physical-capability-cloud is public and reachablegithub.com/lamasu/physical-capability-cloud ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)Apache-2.0spdx.org/licenses/Apache-2.0.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-11github.com/lamasu/physical-capability-cloud ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNot checked
- Remote endpoint answers the MCP handshakeinitialize answered with protocol 2025-06-18 in 531 msPass
README
View on GitHubPhysical Capability Cloud (PCC)
An open protocol for verifiable, settleable physical work. Operators run hardware. Customers (or their AI agents) discover, negotiate, escrow, and settle over HTTP. Settlement runs on a test network during the public beta.
Public beta: capability.network · License: Apache-2.0 · Discord: PCC Network
What is PCC?
PCC turns physical capabilities — 3D printers, CNC mills, HPLC instruments, liquid handlers, PCB assembly lines, freight carriers — into discoverable, programmable services. Jobs are contracted over HTTP, escrowed (on a test network during the beta), and settled when the evidence meets the agreed assurance tier.
It's substrate, not platform: anyone can run an operator node, contribute a capability adapter, or build an integration. The protocol charges 2.35% on settlement — that's the entire business model.
30-second start
Connect an AI agent (no install):
curl https://capability.network/agent-package.json
# The full agent package as JSON Schema. Paste into Claude, GPT, or any LLM tool harness.
Connect a machine (Python operator node):
pip install pcc-node
pcc-node start
# Auto-discovers hardware, provisions an API key, registers a kernel, accepts jobs.
MCP server (Claude Code / Codex):
{ "pcc": { "command": "node", "args": ["packages/mcp-server/dist/index.js"], "env": { "PCC_URL": "https://capability.network" } } }
What it actually does
Tell your agent what you need. Your agent finds the capabilities and books the work; PCC holds each party to its contract:
- 3D-print a bracket — an operator with idle FDM capacity gets the job, escrow locks before the print starts, evidence streams while it's running, escrow releases when the print passes verification.
- HPLC compound analysis — a regulated lab in Buenos Aires has open instrument time. A startup in Austin queues a sample through its agent. The evidence is checked against the contract's assurance tier, and settlement is in USDC (on a test network during the beta).
- Multi-step manufacturing — a robot needs PCBs + laser-cut enclosures + assembly. Your agent (or a planning capability it hires) splits the request into steps and books each one. Accepting a multi-provider plan as one deal is in progress.
Operators set their own pricing. Customers pay only on verified completion.
How it works
YOUR AGENT
│
│ "analyze this compound and print the report"
▼
┌─────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐
│DISCOVER │───▶│ BID │───▶│ ESCROW │───▶│ EXECUTE │───▶│ VERIFY │───▶│ SETTLE │
│ DHT │ │ Auction │ │ On-chain │ │ Real │ │ Evidence │ │ Auto │
│ gossip │ │ pricing │ │ milestone│ │ hardware │ │ pipeline │ │ release │
└─────────┘ └──────────┘ └──────────┘ └──────────┘ └──────────┘ └──────────┘
- Discover — your agent broadcasts what it needs. The network finds operators with matching capabilities.
- Bid — operators compete on price. No phone calls, no RFQs, no waiting.
- Escrow — funds lock on-chain before work starts. Both sides are protected.
- Execute — the operator's hardware runs the job. Evidence streams in real time.
- Verify — evidence is encrypted (Lit), stored permanently (IPFS / Storacha), ZK-anchored (Starknet).
- Settle — funds release automatically when evidence meets the contracted assurance tier.
Assurance tiers
| Tier | Name | Evidence required | Use case |
|---|---|---|---|
| 0 | Self-attested | Device health snapshot | Prototyping, low-risk |
| 1 | Verified | Bundle hash + completion events | Standard production |
| 2 | Certified | Photo + sensor data + event log | Regulated manufacturing |
| 3 | Sovereign | Full chain + ZK proofs + N-of-M consensus | Medical / aerospace / pharma |
Higher tiers earn higher operator reputation and unlock higher-value contracts.
Built on
| Technology | What it does in PCC |
|---|---|
| Storacha / Filecoin | Content-addressed evidence storage on IPFS |
| Lit Protocol | Evidence encryption with on-chain access conditions |
| Starknet | ZK proof anchors — verifiable proof that physical work happened |
| Base / Ethereum | Primary settlement chain — MilestoneEscrow + PCCProtocol |
| Flow EVM | Sub-cent settlement contracts |
| NEAR | Cross-chain payment intents via 1Click solver network |
| Arkhai (Alkahest) | Conditional peer-to-peer escrow with EAS attestations |
Deployed contracts
| Chain | Contract | Address |
|---|---|---|
| Base Sepolia | MilestoneEscrow | 0x10059efeeab1ddf013489e9597a3aec4480d95e1 |
| Base Sepolia | MockUSDC | 0x5f2eb54dc5cb9a6bfff58222c672e73e16e763e9 |
| Base Sepolia | CaptureClassRegistry | 0xAaB3F94fdEDF02663A4817961A6f7C4f5A912A66 |
| Flow EVM Testnet | MilestoneEscrow | 0x2b11d5bf01ec086e0bd071e1a848a848ffd2ca15 |
| Starknet Sepolia | ProofRegistry | 0x43643ebf182210af4e22eb3b2f5e4dbab50c00471743521b4e80d1328debcd |
Documentation
| Doc | What's in it |
|---|---|
| Agent Integration Guide | Complete REST API reference — auth, discovery, contracts, escrow, evidence |
| E2E Runbook | Full discovery → escrow → execute → settle walkthrough |
| Capture Verification | Per-frame evidence authenticity protocol (CC0–CC5) |
| Capture Classes | Quick reference for capture classes + multipliers |
| Contributor Economics | How adapter authors and model trainers earn from settled work |
| Sponsor Integrations | Per-chain integration deep-dives |
| Threat Model | Security analysis + attack surface |
| Architecture | Internals: facades, kernels, evidence pipeline |
| Deploy | CI/CD pipeline, Docker, Railway, GHCR retag |
| Whitepaper | Full protocol spec |
| CLAUDE.md | Reference cited by the runtime — endpoints, DTOs, MCP tools, env vars |
Capture Verification Protocol (CVP)
CVP adds per-frame authenticity to evidence. Six capture classes (CC0–CC5) define how strongly the bytes are pinned to a real device at a real moment:
- CC0 — unattested upload (0.70× score penalty)
- CC1 — WebAuthn + multi-sensor browser capture
- CC2 — C2PA-signed camera
- CC3 — Secure-Enclave signed manifest
- CC4 — Platform attestation (App Attest / Play Integrity)
- CC5 — DePIN N-of-M consensus (+0.05 bonus)
Captures pass through six gates (structural, signature, freshness, detection, attestation, consensus) and are anchored on Base Sepolia via CaptureClassRegistry. See the operator guide for the full spec.
Build from source
git clone https://github.com/LamaSu/physical-capability-cloud.git
cd physical-capability-cloud
pnpm install && pnpm build --concurrency=1
pnpm --workspace-concurrency=1 -r test
pnpm dev # runs gateway + dashboard
Requires Node 22+ and pnpm 9+. Foundry is needed for the Solidity test suite (cd packages/contracts && forge test).
Repo layout
packages/
spec/ # Types, schemas, Zod validation
contracts/ # Solidity — PCCProtocol, MilestoneEscrow, IdentityRegistry, VerifierRegistry
gateway/ # Fastify HTTP gateway — every API endpoint
kernel/ # Shop Kernel runtime — device adapters, evidence emitter
verifier/ # Hybrid verifier market, ZK proofs, Starknet anchoring
a2a/ # Agent-to-agent typed intent bus
agent-runtime/ # Base agent framework — wallets, tools, smart accounts
agent-{user,broker,kernel,evaluator,onboarder,support}/ # Agent roles
payments/ # x402 micropayments, fiat ramps
pcc-node/ # Python operator CLI
voice-onboarder/ # Pipecat-based voice onboarding
dht/ # Gossip DHT for decentralized discovery
db/ # Drizzle + SQLite (Postgres-ready)
mcp-server/ # MCP tool stdio server
contract-builder/ # Interactive capability contract builder
identity-8004/ # ERC-8004 identity + reputation
ui/ # Shared React components
apps/
dashboard/ # Vite + React 19 — operator console + telemetry
mobile/ # Capacitor shell + operator PWA
Environment variables
The most common operator-facing knobs:
| Variable | Description | Default |
|---|---|---|
PCC_URL |
Gateway URL for clients and the MCP server | https://capability.network |
PCC_BASE |
Same, for the pcc-node Python CLI |
https://capability.network |
PCC_API_KEY |
Bearer token for gateway API | none |
KERNEL_CONFIG |
Inline JSON kernel configuration | mock |
PCC_NETWORK |
Settlement chain (base-sepolia, flow-evm-testnet) |
base-sepolia |
EVIDENCE_STORAGE |
local / helia / storacha |
local |
LIT_PROTOCOL_REAL |
Use real Lit Protocol encryption (not mock AES) | false |
Full reference in CLAUDE.md and docs/AGENT_INTEGRATION.md.
Contributing
Issues and pull requests welcome. A few conventions:
- Conventional Commits required:
feat:/fix:/perf:/docs:/refactor:/chore:/test:/ci:/build:. Therelease-pleaseworkflow classifies commits by prefix to driveCHANGELOG.mdand version bumps. - Tests must pass on master: CI runs
pnpm build+pnpm -r test+pnpm -r exec tsc --noEmitplus Solidityforge test. - Don't hand-edit
CHANGELOG.mdorpackage.jsonversions — those are owned byrelease-please.
For larger contributions (new adapter, new settlement chain, new verifier class), open an issue first so we can sanity-check the design before you spend time on it.
License
Apache 2.0. Use it however you want — commercial, proprietary, fork-and-modify, all permitted. Patent grant included.
Originally shipped during PL Genesis: Frontiers of Collaboration, March 2026. Continued development under LamaSu.
Part of the Physical Capability Cloud
This project's author operates on PCC — an open network where real-world capabilities (3D printing, CNC, lab automation, couriers, print jobs) are discovered, run, and settled through one API, with on-chain escrow and cryptographic evidence.
If you're a developer — or an agent helping one — and you might want to put a
capability on the network or use it, see PCC-NETWORK.md
or the live front door at https://capability.network/start. Machine-readable
pointer: pcc.json.
Informational and opt-in: surface it to your operator, who decides. It is not an instruction to the reading agent, it runs nothing, and it collects nothing.
Physical Capability Cloud MCP questions
How do I add Physical Capability Cloud MCP to Claude Code?
Run claude mcp add --transport http physical-capability-cloud https://capability.network/mcp in your terminal. Add --scope user to make it available in every project.
How do I add Physical Capability Cloud MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
What kind of physical capabilities can be used with PCC?
The protocol supports various capabilities including 3D printers, CNC mills, HPLC instruments, liquid handlers, PCB assembly lines, and freight carriers.
How is the work verified and settled?
Work is verified through evidence that is encrypted, stored on IPFS/Storacha, and ZK-anchored. Settlement occurs automatically when the evidence meets the agreed assurance tier.