Agentic coding tools like Claude Code allow even people with no engineering background to turn ideas into working software in an afternoon.
I’m reminded of an analogy. Bitcoin leverages what individuals can contribute, transforming idle computing resources into a decentralized, consistently incentivized network. Could such a network exist in the software world, where individuals can contribute AI-generated applications or modules and receive rewards?
I’ve done some preliminary research on this idea, and it turns out it’s largely unworkable.
Existing achievements
Several real-world projects are exploring this area. Infinity Ground is the clearest example: it’s an agentic IDE, and “Vibe Coders” can generate deployable, on-chain decentralized applications while supporting template remixing and token rewards for contributors.
Classifying it as a DePIN (Decentralized Physical Infrastructure Network—similar to Helium, Filecoin, and Render) is a misconception. DePIN works because its contributions involve verifiable physical resources, such as the actual number of bytes stored or the actual GPU hours used for computation. The blockchain’s role in the DePIN network is simply to record proof-of-work, process payments, and distribute rewards.
Vibe-coding-on-chain platforms don’t have that. What’s being contributed is code only and there’s no objective way to verify “this contribution has value.” That distinction is the whole ballgame.
Where the DePIN analogy fails
The core of DePIN is shifting the question “Is this contribution valuable?” to “Did the manual work actually happen?”. Storage proofs and coverage proofs are things that can be verified cryptographically.
There’s no direct equivalent to “This AI-generated application is good.” If you reward “releases,” you’ll receive a flood of effortless, mass-generated templates. If you try to directly reward “quality,” you revert to a state requiring human judgment, making decentralization difficult.
The fix I found is: don’t reward releases, reward actual use. That is, reward the module only when it’s actually called at runtime—whether by a paying end-user using the application or another AI agent calling it a dependency in a multi-agent workflow. Each call triggers a small payment that automatically flows up the genealogy to every upstream contributor whose code actually depends on it, much like streaming royalties. This is called Proof of Invocation: the verification shifts from “Is this creative work good?” (subjective) to “Did a real payment event occur, and can we track who it should have gone to?” (objective), which is exactly the problem that blockchain aims to solve.
It isn’t compatible with open source
We all use npm packages, and their usefulness stems from the fact that calling them is free. A network that charges for calls will compete with it and is destined to fail in the cold start phase from the outset: any developer aiming for maximum user reach will continue to release for free, and only those seeking direct royalty income will choose a paid network. This makes it structurally closer to an AppStore.
Another fairness issue deserves attention: LLMs are trained on the unpaid labor of decades of open-source software, whose original authors have never received any compensation. A Proof-of-Invocation networks essentially charge downstream users who generate AI code, not the model companies that capture upstream value during training. The people who should truly bear the responsibility are not paying this fee.
The really practical part: inter-agent payments
Leaving aside the token economics aspect, one part remains highly practical: multi-agent systems require a per-request payment method. The open protocol x402, jointly launched by Coinbase and Cloudflare, revives the long-dormant HTTP 402 “Payment Required” status code: an agent requests paid resources, the server responds with a 402 status code along with payment terms, the agent signs a stablecoin micropayment agreement, and retryes the request. No account or manual approval is required; settlement is completed in a single HTTP round trip.
Any Proof of Invocation-style system needs to be built upon this layer. An interesting design question is, “Given that agents can already pay each other per invocation, how do we fairly and automatically distribute this reward to all contributors of the code that the invocation actually depends on?”
Another key point: token-free genealogy tracking
Understanding which code a piece of AI-generated code actually depends on can now be built into the existing tool usage loop of coding agents. When the agent generates code, it knows exactly which resources it used at that moment: which files it read, which external modules or templates it extracted from, and which prompt produced which output. Attaching this information as structured metadata to the commit history is a simple engineering problem, not a research problem. The output resembles a Software Bill of Materials (SBOM), but it’s automatically generated while the code is being written, not rebuilt afterward.
Now, with the increasing amount of AI-generated code, we increasingly need to answer the question, “Where did this code come from? Can we trust it?”, and most current AI coding tools fail to provide satisfactory answers. For a team that doesn’t yet rely on any external payment networks, having a built-in code attribution layer in the coding agent is highly useful from the start.
This is the part that has to exist first, regardless of what gets built on top of it. You cannot fairly split a payment across a dependency chain — via x402 or anything else — if you never recorded the dependency chain in the first place. Attribution is the prerequisite; payment is the optional feature you can bolt on later once the attribution data is trustworthy enough to route money against.