P2PCP (P2P Compute Protocol)

[SkepticusMaximus]

I found Jan in the course of searching for a host platform with the correct FOSS principles and features, that supports local models and has a permissive view to either being forked or collaborative co-development to the original code-base. I found Jan to be the ideal candidate in every respect. But the question of a possible friendly fork or integration within the existing code base is the moot question to resolve. Thanks in advance for any advice on this matter.

The project is somewhat ambitious but I do believe the benefits will outstrip the dev overheads: Please find attached a seed document The first few paragraphs serve as an introduction:

P2PCP — P2P COMPUTE PROTOCOL
PROJECT SEED DOCUMENT

Status: Concept / Early Definition Stage
Date: April 2026
Author: Stevo (SkepticusMaximus)
Repository: TBD

PROJECT OVERVIEW

P2PCP (P2P Compute Protocol) is a proposed open, model-agnostic protocol for
decentralised AI compute exchange over a peer-to-peer network. It is designed
from the ground up to be:

• Application-agnostic (any local AI frontend can implement it)
• Model-agnostic (binary, ternary, quantised — any inference backend)
• Extensible (other protocols may run on top of P2PCP)
• Self-sustaining (compute is both the work and the reward)

The TCP/IP analogy is intentional: P2PCP is infrastructure. Applications and
higher-order protocols are built on top of it, not embedded within it.

THE FLAGSHIP APPLICATION: P2PAI

P2PAI is the reference implementation application built on P2PCP. It uses Jan
(FOSS, community-driven, integration-friendly) as the local agent and user
experience layer. Jan's architecture is explicitly designed for integration
into other projects, making it the natural first-class citizen on P2PCP.

P2PAI handles:

• User interaction with their local AI model
• CompuToken wallet and balance management
• Connection to the P2PCP node network
• Earning compute credits from idle hardware
• Spending compute credits to offload inference to other nodes

Jan's role is the bridge between the user and the protocol. The protocol
itself does not depend on Jan — any compliant frontend can participate.

THE CORE CONCEPT: COMPUTE AS COMMODITY

The fundamental insight: idle compute on consumer hardware is a real,
measurable, spendable resource. It currently goes to waste. P2PCP turns
it into a transactable asset.

How it works:

Idle cycles → contributed to the P2P network → earn CompuTokens
Compute needed → pull from the network → spend CompuTokens

A device does not need to own enough compute to run a model. It contributes
what it has, earns credit, and draws on the collective mesh when it needs more
than it can provide locally. The network balances load across all nodes.

This is similar in spirit to SETI@home (distributed compute contribution)
combined with a crypto token credit system — but the compute is useful on
demand, not just scientific background processing.

For further details please see the full seed document attached:

P2PCP-Project-Seed.txt

NB: I did a search here on P2P and only found a proprietary company providing API and a phone app. I am aiming for entirely FOSS from the ground up, with an open protocol and freely OS downstream extensibility. This company Nataris, appears to be extremely hostile to code sharing and I can see no license link on their website, but it certainly won't be Open Source, despite that their code-base is itself built on/from OS code. P2PCP is a very different beast.