Physical Capability Cloud MCP server
Commit 14. Nov. 2026Ermöglicht es AI Agents, reale physische Services wie 3D-Druck oder Laborautomatisierung über ein verifizierbares Protokoll zu finden, auszuhandeln und zu buchen.
Auch bekannt als LamaSu/physical-capability-cloud, physical-capability-cloud
- Stars
- 3
- Tools
- —
- Downloads, 30 Tage
- —
- Neueste Version
- 2.19.0
- Letzter Commit
- 14. Nov. 2026
- Lizenz
- Apache-2.0
Was ist Physical Capability Cloud MCP?
Ermöglicht es AI Agents, reale physische Services wie 3D-Druck oder Laborautomatisierung über ein verifizierbares Protokoll zu finden, auszuhandeln und zu buchen.
Zusammenfassung generiert aus dem README des Projekts
Über Physical Capability Cloud MCP server
Physical Capability Cloud bietet ein offenes Protokoll, um physische Hardware in programmierbare Services zu verwandeln. Es ermöglicht AI Agents und Entwicklern, reale Aufgaben wie 3D-Druck, CNC-Fräsen und Laborautomatisierung zu finden, auszuhandeln und zu buchen. Das System fungiert als Substrat, auf dem Betreiber Hardware betreiben und Kunden Aufträge über HTTP vergeben, wobei On-Chain-Escrow genutzt wird, um beide Parteien während der Ausführungsphase zu schützen.
Nutzer können einen AI Agent verbinden, indem sie ein JSON-Schema-Paket abrufen, oder einen MCP server für die Nutzung mit Tools wie Claude Code bereitstellen. Betreiber können Maschinen über einen Python-Node integrieren, der Hardware automatisch erkennt und API-Keys bereitstellt. Das Protokoll gewährleistet Vertrauen durch verschiedene Assurance Tiers – von einfachen, selbst attestierten Geräte-Snapshots bis hin zu souveränen, ZK-verankerten Proofs für regulierte Branchen wie die Medizin- oder Luftfahrtfertigung. Die Abrechnung erfolgt automatisch, wenn die kryptografischen Nachweise die vereinbarten Vertragsanforderungen erfüllen.
Was du damit machen kannst
- 1Automatisierte Beschaffung von 3D-DruckenEin AI Agent kann einen freien FDM-Drucker finden, Gelder im Escrow sperren und den Druckprozess über Streaming-Nachweise überwachen.
- 2Remote-LaboranalyseEin Entwickler kann einen Agent nutzen, um chemische Verbindungsanalysen in einem regulierten Labor in einem anderen Land in eine Warteschlange einzureihen.
- 3Komplexe mehrstufige FertigungEin Agent kann eine große Fertigungsanfrage in einzelne Schritte zerlegen und für jeden Teil des Prozesses verschiedene Anbieter beauftragen.
Geschrieben aus dem README des Projekts. Jeder Use Case wurde gegen ein Zitat daraus geprüft.
So installierst du Physical Capability Cloud MCP
Formate geprüft am 10. Nov. 2026Zu Cursor hinzufügenZu Goose hinzufügenPhysical Capability Cloud MCP in Claude Code installieren
$ claude mcp add --transport http physical-capability-cloud https://capability.network/mcpPhysical Capability Cloud MCP in Cursor installieren
~/.cursor/mcp.json
{
"mcpServers": {
"physical-capability-cloud": {
"url": "https://capability.network/mcp"
}
}
}Physical Capability Cloud MCP in VS Code installieren
.vscode/mcp.json
{
"servers": {
"physical-capability-cloud": {
"type": "http",
"url": "https://capability.network/mcp"
}
}
}Physical Capability Cloud MCP in VS Code CLI installieren
$ code --add-mcp '{"name":"physical-capability-cloud","type":"http","url":"https://capability.network/mcp"}'Physical Capability Cloud MCP in Codex installieren
$ codex mcp add physical-capability-cloud --url https://capability.network/mcpPhysical Capability Cloud MCP in Codex config.toml installieren
~/.codex/config.toml
[mcp_servers.physical-capability-cloud] url = "https://capability.network/mcp"
Physical Capability Cloud MCP in Gemini CLI installieren
$ gemini mcp add -s user --transport http physical-capability-cloud https://capability.network/mcpPhysical Capability Cloud MCP in Gemini settings.json installieren
~/.gemini/settings.json
{
"mcpServers": {
"physical-capability-cloud": {
"url": "https://capability.network/mcp",
"type": "http"
}
}
}Konfiguration
PCC_URL
| Name | Beschreibung | Typ |
|---|---|---|
| PCC_URL | — |
Automatisierte Checks
Geluften am 14. Nov. 2026Vollständiger Bericht →Noch nicht verifiziert. Ein Server benötigt einen Score von 80, keine kritischen Befunde und genug Daten für unsere Prüfung. Wie die Checks funktionieren · Was du für mehr Punkte verbessern kannst
- Source Repository verknüpft und erreichbarlamasu/physical-capability-cloud is public and reachablegithub.com/lamasu/physical-capability-cloud ↗Bestanden
- Paket nennt dieses Repository als QuelleNicht geprüft
- Build-Provenienz (Sigstore-Attestierung)Nicht geprüft
- Open Source Lizenz (OSI)Apache-2.0spdx.org/licenses/Apache-2.0.html ↗Bestanden
- Commit oder Release im letzten JahrLast commit or release 2026-11-11github.com/lamasu/physical-capability-cloud ↗Bestanden
- OpenSSF ScorecardNicht geprüft
- Package-Name ähnelt keinem populären PackageNicht geprüft
- Keine kritischen Advisories im Paket oder seinen AbhängigkeitenNicht geprüft
- Keine versteckten Anweisungen an das Modell0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersBestanden
- Destruktive Tools sind markiertNicht geprüft
- Remote-Endpoint beantwortet den MCP-Handshakeinitialize answered with protocol 2025-06-18 in 531 msBestanden
README
Auf GitHub ansehenPhysical 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 Fragen
Wie füge ich Physical Capability Cloud MCP zu Claude Code hinzu?
Führe claude mcp add --transport http physical-capability-cloud https://capability.network/mcp in deinem Terminal aus. Füge --scope user hinzu, damit der Server in jedem Projekt verfügbar ist.
Wie füge ich Physical Capability Cloud MCP zu Cursor hinzu?
Öffne ~/.cursor/mcp.json und füge den Server unter mcpServers hinzu, mit der Cursor-Config aus dem Installationsabschnitt oben.
Welche Arten von physischen Fähigkeiten können mit PCC genutzt werden?
Das Protokoll unterstützt verschiedene Funktionen, darunter 3D-Drucker, CNC-Fräsen, HPLC-Instrumente, Liquid Handler, PCB-Bestückungslinien und Frachtführer.
Wie werden die Arbeiten verifiziert und abgerechnet?
Die Arbeit wird durch Nachweise verifiziert, die verschlüsselt, auf IPFS/Storacha gespeichert und per ZK-Anker gesichert werden. Die Abrechnung erfolgt automatisch, sobald die Nachweise die vereinbarte Assurance Tier erfüllen.