Centram — engineering log

01 — what's actually here

Eight components, three honest categories.

Below is the full surface area of the project, classified by whether the code ships, exists as a working demo, or is currently open (designed but not empirically validated). Nothing else.

Component	What it does	Status
Local LLM + LoRA training	Train on-device, extract weight deltas, persist genomes.	Ships
P2P binary protocol	96 message types, Ed25519-signed, QUIC transport, LAN discovery.	Ships
Genome merge operators	SLERP, TIES, DARE-TIES weight-space interpolation (mergekit-equivalent).	Ships
10-layer validation gate	Differential privacy, lineage cycle detection, fitness gating, signatures.	Ships
Hyperlink distributed inference	Two-process pipeline parallelism. Bit-exact equivalence to single-process. Toy GPT only.	Demo
DETRA / CyBank / Dashboard	Three Flutter apps shipping with the daemon (chat, wallet, node UI).	Beta
Cross-domain genome aggregation	Whether peer LoRA exchange improves generalist fitness across nodes. Five toy-scale tests are flat.	Open
CEN economy & royalty ledger	Lineage-decay royalties tracked locally; cross-peer reconciliation not yet hardened.	Open

Earlier versions of this page used the word “novel” in several places. Most of what's listed above composes well-understood primitives (federated learning, model merging, pipeline parallelism, Byzantine fault tolerance) into a working system. Useful in combination, not new in isolation. See HONEST_STATUS.md.

02 — the working MVP

Two processes hold half a transformer each.

The most novel claim in the project — that a model can run distributed across peer-to-peer nodes — existed only as a docstring and a layer-assignment planner before this log was written. We built the smallest demonstrable version: 600 lines, three files, two HTTP servers, one coordinator.

$ python experiments/hyperlink_mvp/demo.py# after spawning 2 shard servers (layers 0-1, layers 2-3)

[1/2] Baseline single-process generation…
      wall_ms = 51.6

[2/2] Distributed generation across 2 shards…
      tokens = 30
      ms_per_token = 7.61
      shard_compute = 85.2 ms
      network_overhead = 132.1 ms (57.9%)

EQUIVALENCE CHECK
  Baseline tokens : [106, 117, 109, 112, 115, 32, …]
  Distributed     : [106, 117, 109, 112, 115, 32, …]
  Match           : True

VERDICT: PASS — distributed pipeline produced bit-exact tokens.

4.4× slower than single-process is expected at 842K params: per-token compute finishes in ~1.7 ms, leaving HTTP serialization to dominate. At 1B+ params, compute scales quadratically with hidden dim while activation-passing only scales linearly — the network fraction shrinks fast. Full source: experiments/hyperlink_mvp/.

03 — the five experiments

If peers exchange knowledge, generalist quality should rise. It doesn't — yet.

The actual product claim of decentralized evolution is that nodes training on different things, when they exchange weight deltas, produce a network that's collectively better at all of them. The fair test is fitness on domains other than what each peer trained on. We ran five variants of this test at 842K-parameter toy scale.

All five are flat or declining at this scale. We say so plainly.

Variant	own Δ	generalist Δ	cross Δ	accept	verdict
Delta, divergent corpora	+0.0347	−0.0277	—	5.0%	declines
LoRA, divergent corpora	+0.0179	+0.0034	—	0.0%	flat
LoRA, same domain (registers)	+0.0156	−0.0022	−0.0030	1.7%	flat
LoRA, SLERP operator (same)	+0.0156	−0.0023	−0.0030	0.0%	flat
LoRA, topic-overlap rich data	+0.0070	−0.0006	−0.0013	3.3%	flat

Every variant trains successfully on its own corpus — the own Δ column is positive across the board. But cross-node aggregation, the part that actually justifies the network, produces no measurable lift at this scale, regardless of operator (linear vs SLERP) or data design (independent topics vs topic-overlapping).

The remaining hypothesis is scale. The same pipeline at 1.5B+ parameters may behave differently — a matter for cloud GPUs and a separate session. Results will be published here, positive or negative, when the evidence is in.

The right benchmark for a decentralized AI system is not the easy case — it is whether the project shows you the hard case and tells you which parts are still open. — from docs/HONEST_STATUS.md

05 — architecture, plainly named

Three layers, three honest names.

Earlier versions of this site framed each layer as a novel theory — IEIT, DNA, GWP. The architecture papers are still online (linked below) for anyone who wants the original framing. The plain-language version is shorter:

Federated LoRA exchange. Each peer trains its adapter locally, packages weight deltas as genomes, and shares them. A 10-step validation gate accepts or rejects based on differential privacy, lineage acyclicity, and a fitness-regression check. Marketed as “IEIT”.
P2P pipeline parallelism. Each peer holds a slice of model layers and forwards activations to the next peer in line. The Hyperlink MVP in § 02 is the working core of this; production-ready features (KV-cache, streaming, replica selection) are engineering ahead. Marketed as “DNA”.
Self-refinement ensemble. Multiple peers answer the same query; outputs are reconciled, contradictions detected, a deepening loop runs until convergence. Currently heuristic (string matching + scoring); a semantic-grounded version is in design. Marketed as “GWP”.

06 — running it yourself

Four commands. Two minutes.

install · macos / linux# 1. install the daemon
$ pip install -e daemon/
$ centram-daemon --data-dir ~/.centram

# 2. download a model (Qwen 2.5 3B)
$ centram-model download qwen2.5-3b

# 3. run the Hyperlink MVP demo
$ python experiments/hyperlink_mvp/demo.py
   VERDICT: PASS

# 4. (optional) launch a Flutter app
$ cd detra && flutter run

The daemon is a Python package with a Rust crypto core. The Flutter apps are optional — the REST API on port 9740 is the source of truth. Full guide: GETTING_STARTED.md.