Panas: Turning Idle Machines Into a Peer-to-Peer Market for Agents

Autonomous agents need compute and infrastructure to run, while thousands of capable machines sit idle on developers’ desks for most of the day. If you bought a Mac mini during the OpenClaw frenzy earlier this year, chances are you are using expensive hardware just to classify emails and run small personal tasks that barely touch the chip, wasting resources that could be serving other agents and earning money.

While most hackathon projects wrap an API key inside a landing page, Erick Rico and I took second place at the Codex Community hackathon in Guadalajara with Panas, a complete distributed infrastructure stack we built in 24 hours as a two-person team. Since we already had Macs with spare compute and MCPWire to link them peer-to-peer, we built the missing layer so any agent can discover an available machine on its own, lock in a price, and execute a workload without a human ever setting up the connection.

How Panas Works

Panas exposes that entire lifecycle through MCP so an agent can buy and run remote compute the exact same way it calls a local tool. The agent discovers an available provider and gets a fixed quote, and then the provider verifies a signed cryptographic grant that binds the request to a model, workload limits, and price before accepting the job. Once verified, the payload travels over an encrypted MCPWire tunnel to a gateway container that hands the job to a separate, locked-down Docker worker sandbox running with networking disabled, a read-only filesystem, dropped Linux capabilities, and strict resource limits, so external workloads never touch the host machine, its files, or its private network.

Orchestrating Parallel Agents Across 18 Git Worktrees

Shipping a control plane, an append-only accounting ledger, on-chain payment verification, peer-to-peer transport, and an isolated Docker runtime in a single day with two people required running a fleet of Codex agents in parallel across 18 separate Git worktrees. Instead of letting agents step on each other’s files, we split the repository by what each branch could implement and verify independently, tying the worktrees together through shared TypeScript contracts for every payload they exchanged. That let the provider branch verify container confinement and model staging, the transport branch test encrypted peer connections, and the registry branch test lease expiration when a machine drops offline, all running simultaneously without a single merge collision.

The buyer’s MCP facade was where all those parallel branches had to converge, because a single request crosses discovery, accounting reservations, and peer transport before the provider container ever runs a job. We used deterministic fixtures so the buyer branch could build against the shared contracts while the other worktrees were still moving, then replaced them with integration checks designed to break the handoffs between services. One case captures the real difficulty of distributed execution: the provider finishes running the workload, the buyer loses the connection right before reading the response, and a retry has to recover the original encrypted result and receipt without running the model or charging the buyer twice.

Beyond Inference: A Paywall for Any MCP Tool

For the live test, we connected the four machines we had on the table, and a buyer agent discovered a ready provider on its own, sent "Say hello in one short sentence", and pulled back the output with a $0 receipt in two seconds. The point of that test was not the five words of text it returned, but what happened underneath a single tool call: autonomous discovery across separate hardware, cryptographic budget verification, an encrypted peer tunnel with zero port forwarding, air-gapped Docker execution, and a settled receipt with no human in the loop. Even though we ran the demo with free providers, the paywall and USDC settlement on Solana are already live, so linking your wallet in the startup flags and setting a price turns your machine into a paid node immediately.

We used Macs simply because that was the hardware we brought with us and we pinned a small model to keep the live test fast, but the entire runtime runs on Linux and the model is just a configuration flag, so if you have an NVIDIA DGX or a Mac mini with 128 GB of RAM you can serve heavyweight models by changing one parameter. And more importantly, model inference was only the excuse for the demo, because that exact same pipeline can expose a database, gate access to a private internal system, or serve any software layer for agents while charging per execution transparently, securely, and anonymously. Most people today barely use MCP to wire up local toy scripts on localhost, and in a few hours we proved the protocol can run an entire peer-to-peer market of compute and tools without a single data center.