MCP server de Physical Capability Cloud
Commit 14 nov 2026Permite que los agentes de IA descubran, negocien y reserven servicios físicos del mundo real, como impresión 3D y automatización de laboratorios, a través de un protocolo verificable.
También conocido como LamaSu/physical-capability-cloud, physical-capability-cloud
- Stars
- 3
- Herramientas
- —
- Descargas, 30 días
- —
- Última versión
- 2.19.0
- Último commit
- 14 nov 2026
- Licencia
- Apache-2.0
¿Qué es Physical Capability Cloud MCP?
Permite que los agentes de IA descubran, negocien y reserven servicios físicos del mundo real, como impresión 3D y automatización de laboratorios, a través de un protocolo verificable.
Resumen generado a partir del README del proyecto
Acerca del MCP server de Physical Capability Cloud
Physical Capability Cloud proporciona un protocolo abierto para convertir hardware físico en servicios programables. Permite que agentes de IA y desarrolladores descubran, negocien y reserven tareas del mundo real como impresión 3D, fresado CNC y automatización de laboratorios. El sistema funciona como un sustrato donde los operadores ejecutan hardware y los clientes contratan trabajo a través de HTTP, utilizando depósitos en garantía (escrow) on-chain para proteger a ambas partes durante la fase de ejecución.
Los usuarios pueden conectar un agente de IA obteniendo un paquete de esquema JSON o desplegar un MCP server para usarlo con herramientas como Claude Code. Los operadores pueden integrar máquinas mediante un nodo de Python que descubre automáticamente el hardware y provisiona claves API. El protocolo garantiza la confianza a través de varios niveles de garantía, que van desde simples instantáneas de dispositivos autoatestadas hasta pruebas soberanas ancladas en ZK para industrias reguladas como la fabricación médica o aeroespacial. La liquidación ocurre automáticamente cuando la evidencia criptográfica cumple con los requisitos del contrato acordado.
Qué puedes hacer con él
- 1Adquisición automatizada de impresión 3DUn agente de IA puede encontrar una impresora FDM inactiva, bloquear fondos en escrow y monitorear el proceso de impresión mediante evidencia en streaming.
- 2Análisis de laboratorio remotoUn desarrollador puede usar un agente para poner en cola el análisis de compuestos químicos en un laboratorio regulado ubicado en otro país.
- 3Fabricación compleja de múltiples pasosUn agente puede descomponer una solicitud de fabricación de gran escala en pasos individuales y contratar a diferentes proveedores para cada parte del proceso.
Escrito a partir del README del proyecto. Cada caso de uso se verifica con una cita del mismo.
Cómo instalar Physical Capability Cloud MCP
Formatos verificados el 10 nov 2026Añadir a CursorAñadir a GooseInstalar Physical Capability Cloud MCP en Claude Code
$ claude mcp add --transport http physical-capability-cloud https://capability.network/mcpInstalar Physical Capability Cloud MCP en Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"physical-capability-cloud": {
"url": "https://capability.network/mcp"
}
}
}Instalar Physical Capability Cloud MCP en VS Code
.vscode/mcp.json
{
"servers": {
"physical-capability-cloud": {
"type": "http",
"url": "https://capability.network/mcp"
}
}
}Instalar Physical Capability Cloud MCP en VS Code CLI
$ code --add-mcp '{"name":"physical-capability-cloud","type":"http","url":"https://capability.network/mcp"}'Instalar Physical Capability Cloud MCP en Codex
$ codex mcp add physical-capability-cloud --url https://capability.network/mcpInstalar Physical Capability Cloud MCP en Codex config.toml
~/.codex/config.toml
[mcp_servers.physical-capability-cloud] url = "https://capability.network/mcp"
Instalar Physical Capability Cloud MCP en Gemini CLI
$ gemini mcp add -s user --transport http physical-capability-cloud https://capability.network/mcpInstalar Physical Capability Cloud MCP en Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"physical-capability-cloud": {
"url": "https://capability.network/mcp",
"type": "http"
}
}
}Configuración
PCC_URL
| Nombre | Descripción | Tipo |
|---|---|---|
| PCC_URL | — |
Verificaciones automáticas
Ejecutado 14 nov 2026Informe completo →Aún no verificado. Un servidor necesita una puntuación de 80, ningún hallazgo grave y suficientes datos para que podamos revisarlo. Cómo funcionan las verificaciones · Qué corregir para obtener más puntos
- Repositorio de origen vinculado y accesiblelamasu/physical-capability-cloud is public and reachablegithub.com/lamasu/physical-capability-cloud ↗Aprobado
- El paquete indica este repositorio como su origenNo verificado
- Procedencia de la compilación (atestación de Sigstore)No verificado
- Licencia de código abierto (OSI)Apache-2.0spdx.org/licenses/Apache-2.0.html ↗Aprobado
- Commit o lanzamiento en el último añoLast commit or release 2026-11-11github.com/lamasu/physical-capability-cloud ↗Aprobado
- OpenSSF ScorecardNo verificado
- El nombre del paquete no es similar a un paquete popularNo verificado
- No hay avisos críticos en el paquete ni en sus dependenciasNo verificado
- Sin instrucciones ocultas para el modelo0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersAprobado
- Las herramientas destructivas están etiquetadasNo verificado
- El endpoint remoto responde al handshake de MCPinitialize answered with protocol 2025-06-18 in 531 msAprobado
README
Ver en 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.
Preguntas sobre Physical Capability Cloud MCP
¿Cómo agrego Physical Capability Cloud MCP a Claude Code?
Ejecuta claude mcp add --transport http physical-capability-cloud https://capability.network/mcp en tu terminal. Añade --scope user para que esté disponible en todos los proyectos.
¿Cómo agrego Physical Capability Cloud MCP a Cursor?
Abre ~/.cursor/mcp.json y añade el servidor en mcpServers, usando la configuración de Cursor que se muestra en la sección de instalación de arriba.
¿Qué tipo de capacidades físicas se pueden utilizar con PCC?
El protocolo admite diversas capacidades, incluyendo impresoras 3D, fresadoras CNC, instrumentos HPLC, manipuladores de líquidos, líneas de ensamblaje de PCB y transportistas de carga.
¿Cómo se verifica y liquida el trabajo?
El trabajo se verifica mediante evidencia que se cifra, se almacena en IPFS/Storacha y se ancla mediante ZK. La liquidación ocurre automáticamente cuando la evidencia cumple con el nivel de garantía acordado.