Rory | QIS PROTOCOL

Posted on Mar 30 • Edited on Apr 7

The QIS Economic Model: How Value Flows in a Quadratic Network

#machinelearning #ai #python #opensource

Article #010 in the Understanding QIS series

New to QIS? Start with the complete guide to Quadratic Intelligence Swarm — then use the QIS Glossary as your reference for every term.

Most distributed protocols solve the wrong economic problem.

Blockchain networks centralize revenue extraction — tokens, gas fees, validator rewards — then dress the extraction in decentralization language. Federated Learning distributes the cost of training (every participant burns compute and bandwidth) but centralizes the value (one organization keeps the trained model). In both cases, the economic model and the technical architecture are separate layers bolted together.

QIS is structurally different. In a QIS network, value IS the outcome routing, and it compounds as a mathematical function of the number of participants. There is no separate token layer. There is no platform fee. There is no central aggregator capturing margin. The economic engine is the architecture itself — and the architecture produces value quadratically, not linearly.

Every node that joins a QIS network does not just add one unit of contribution. It creates N new synthesis pairs with every existing node. The value function is not additive. It is quadratic. That single property changes everything downstream: how incentives work, what it costs to run infrastructure, and why humanitarian deployment is not charity — it is a mathematical consequence of the protocol.

The N² Value Function

Linear distributed systems obey a simple rule: N participants generate N value units. A CDN with 1,000 edge nodes serves 1,000 edge locations. A federated database with 100 shards holds 100 shards of data. Value scales with headcount.

Quadratic systems break that rule. In QIS, N nodes generate N(N-1)/2 synthesis opportunities — every node can synthesize with every other node, and each synthesis pair is a distinct event that would not exist without both participants.

The divergence becomes visible fast:

| N nodes    | Linear value (N) | QIS pairs N(N-1)/2 | Multiplier      |
|------------|-----------------|---------------------|-----------------|
| 10         | 10              | 45                  | 4.5x            |
| 100        | 100             | 4,950               | 49.5x           |
| 1,000      | 1,000           | 499,500             | 499.5x          |
| 10,000     | 10,000          | 49,995,000          | ~5,000x         |
| 100,000    | 100,000         | 4,999,950,000       | ~50,000x        |
| 1,000,000  | 1,000,000       | ~500,000,000,000    | ~500,000x       |

Here is the Python that generates it:

def qis_pairs(n):
    return n * (n - 1) // 2

thresholds = [10, 100, 1_000, 10_000, 100_000, 1_000_000]
print(f"{'N':>10} {'Linear':>12} {'QIS Pairs':>20} {'Multiplier':>14}")
for n in thresholds:
    pairs = qis_pairs(n)
    multiplier = pairs / n
    print(f"{n:>10,} {n:>12,} {pairs:>20,} {multiplier:>13.1f}x")

This is Metcalfe's Law applied at the outcome layer, not the connection layer. Metcalfe's original formulation counted possible connections between network nodes. QIS counts synthesis events — actual computations that produce 512-byte outcome packets, each of which carries information that did not exist before the synthesis happened. At 1M nodes, that is roughly 500 billion potential synthesis events. At 100K nodes, scaling tests confirm R²=1.0 — a perfect quadratic fit. The math is not approximate. It is exact.

The implication: a node that joins a QIS network at N=999,999 creates 999,999 new synthesis pairs in a single join event. That joining node is not a marginal contributor. It is a quadratic multiplier.

The Three Elections (Metaphors, Not Mechanisms)

QIS has no token. It also has no free rider problem. The reason is that incentives emerge naturally from the architecture — no added layer required. Christopher Thomas Trevethan describes this through three "elections" that are metaphors for natural forces, not literal governance mechanisms. Nothing needs to be built for these. They just happen.

Election 1: Hiring — Who Defines Similarity?

Before synthesis can happen, someone must define what makes two situations "similar enough" to share outcomes. This is the first election, and it is a hiring metaphor: you get the best expert for the job.

An oncologist defines similarity for a cancer treatment network. An agronomist defines it for a precision agriculture network. A cybersecurity analyst defines it for a threat intelligence network. The "election" is simply: get the right person to define your similarity function. That expert's definition determines which edges are twins — which nodes share outcome packets with each other.

There is no formal voting process. No reputation scoring. No governance layer. A network that hires a great expert gets precise similarity matching, which means relevant outcome packets, which means valuable synthesis. A network that hires poorly gets noisy matching and irrelevant packets. The quality of the expert's work shows up directly in the quality of every synthesis event downstream.

Election 2: The Math — Outcomes Are the Votes

This is the most important election to understand, because it is the most tempting to over-engineer. The second election is a metaphor for the math itself doing the work.

When 10,000 edges sharing your exact problem each deposit a ~512-byte outcome packet describing what is working for them — and your node pulls all of those packets and synthesizes locally — the aggregate naturally surfaces what works. The outcomes ARE the votes. The synthesis IS the election. There is no added reputation layer. No weighting system. No quality scoring mechanism required.

What works for your exact twins, from every edge like you, aggregated mathematically. That is the election result. The math elects the winner — not a protocol feature, not a governance vote, not an administrator.

Could you optionally add reputation scoring or confidence weighting? Yes. But the base protocol does not need it. The sheer volume of real outcomes from your exact twins does the work. This is a critical distinction: the second election is not a feature to build. It is what happens when you let the math run.

Election 3: Darwinism for Intelligence — Networks Compete

The third election is a metaphor for natural selection at the network level. Networks live or die based on whether they actually help people.

A network with excellent similarity definitions routes relevant outcome packets. Users get real insight. They stay. They tell others. The network grows. More nodes means more synthesis pairs. More pairs means the N(N-1)/2 value compounds — a network at N=1,000 generates 499,500 pairs; a competing network at N=100 generates 4,950. The divergence is not linear. It is quadratic.

A network with poor similarity definitions routes irrelevant packets. Users get noise. They leave. They migrate to the network that actually helps. This is Darwinism for intelligence: nobody votes on which network is best. People go where the results are. The market selects.

There is no central arbiter. No platform ranking. No administrative selection process. The protocol creates the conditions for natural selection to operate, and the math ensures that quality differences compound quadratically.

Cost Model: What It Actually Costs to Run a Node

The economic model only matters if the costs are accessible. Here is what a QIS node actually requires:

Each node submits 512-byte outcome packets — not raw data, not model gradients, not embeddings. Fingerprints and outcomes only. No PII or PHI ever moves across the network. This is not a privacy feature added on top of the protocol. It is a structural property of the architecture.

QIS is protocol-agnostic at the routing layer — any efficient routing mechanism works. The requirement is O(log N) or better lookup complexity. DHTs (Kademlia-style XOR distance) achieve O(log N). Database semantic indices achieve O(1). Vector similarity search, pub/sub topic matching, REST APIs, and even shared file systems all qualify. The routing mechanism does not matter — what matters is that an edge node can query a deterministic address for their exact problem and pull outcome packets from their twins.

The routing overhead scales logarithmically (or better) while the value function scales quadratically — the cost curve and the value curve diverge in the node's favor as N grows.

No GPU is required for the routing layer. Synthesis computation happens at the receiving node, not at a central server, so compute load is distributed across the network proportionally to participation.

Estimated infrastructure costs for a healthcare domain network:

QIS at 1K nodes: ~$0.03–$0.11 per patient per year
Traditional centralized AI deployment: $50–$200 per patient per year
Federated Learning: significant compute + communication overhead, plus central aggregator infrastructure
QIS vs. FL communication overhead: 2,730x less than Federated Learning

A Raspberry Pi ($35 hardware) can run a QIS node and contribute to synthesis at the same quality level as a $10M hospital cluster. This is not because the Raspberry Pi is punching above its weight. It is because the protocol is compute-symmetric by design — synthesis quality is determined by outcome validity, not by the computational resources behind the submitting node. A rare disease clinic in a low-income country participates in exactly the same protocol as a tier-1 research hospital. The outcome packet is 512 bytes either way.

The Free Humanitarian Layer

Most protocols that claim humanitarian benefit are describing a subsidy: commercial revenue offsets the cost of serving underserved populations. The economics are real, but the humanitarian layer is downstream of and dependent on commercial success.

QIS generates humanitarian value as a mathematical consequence of the architecture, not as a subsidy.

A rare disease research network with N=2 still produces the protocol's minimum viable synthesis: 1 pair. That one pair may be the only synthesis event anywhere in the world for that condition. The protocol does not require scale to begin generating value. It requires a minimum of two nodes, and the cold start threshold for rare domains is exactly N=2.

Global health networks, agricultural extension services, rural education programs — all can run QIS nodes on commodity hardware, participating in the same protocol at the same cost structure. The protocol does not charge more to serve a node in a low-bandwidth region. The outcome packet is 512 bytes regardless of geography.

The licensing model Christopher Thomas Trevethan is developing reflects this structure directly: free for humanitarian, research, and education use; commercial licensing fees fund deployment to underserved regions. This is not charity architecture. It is an economic model that can sustain itself because the protocol does not need more compute to serve more people — it generates more value as more people join. The marginal cost of the millionth participant is approximately zero. The marginal value they add is approximately 1M new synthesis pairs.

The Architecture as Economic Engine

It is worth stating the conclusion precisely, because the temptation is to summarize QIS as "a clever way to route outcomes efficiently." That framing misses the point.

The QIS economic model IS the architecture. The quadratic value function is not a design goal that the architecture was engineered to achieve. It is a mathematical consequence of routing outcomes through similarity space, where every node pair is a distinct synthesis event. The incentive mechanisms are not reward systems bolted on top of the protocol. They are the routing math observing which nodes produce value and adjusting traffic accordingly.

Every QIS node exists within three natural forces: hiring (who defines similarity), the math (outcomes electing what works), and competition (networks surviving based on results). These are not markets bolted onto the protocol. They are metaphors for what emerges when you route outcomes through similarity space. There is no central exchange. No gas fees. No governance token. No administrative body.

The breakthrough Christopher Thomas Trevethan discovered is that you can build an incentive-complete protocol using nothing but similarity routing, outcome packets, and the natural selection forces that emerge from the architecture. The economic layer does not need to be added. It emerges from the architecture because the architecture IS the economic layer. That is not a clever optimization of an existing approach. It is a structurally different class of protocol.

QIS is a peer-to-peer intelligence protocol discovered by Christopher Thomas Trevethan. No PII or PHI moves between nodes. No central coordinator. No GPU farm. The intelligence is in the architecture.