Hyperspace

60.1 Overview & Motivation

Hyperspace is a two-layer system combining a production-grade decentralized peer-to-peer AI inference network with a distributed autoresearch layer (Hyperspace AGI) in which autonomous agents collaboratively run experiments, share findings via gossip protocols, and archive results to Git [README]. The infrastructure layer, built on libp2p and IPFS-derived protocols, reports over 2 million active nodes and 3.6 million client downloads [README]. The research layer, created on March 8, 2026—two days after Karpathy's autoresearch release—extends the single-agent autoresearch pattern to a massively distributed multi-agent discovery system [README].

The motivating problem is well-defined: single-agent autoresearch, as demonstrated by Karpathy (March 6, 2026), is fundamentally bounded by the compute of a single GPU, the ideation capacity of a single agent, and the absence of cross-agent knowledge transfer [PAPER]. Hyperspace AGI proposes to overcome these constraints by distributing research across thousands of agents communicating via gossip protocols, maintaining convergent state through conflict-free replicated data types (CRDTs), and archiving results durably to GitHub [PAPER].

The system is positioned as "BitTorrent for AI inference" in its whitepaper, drawing intellectual lineage from P2P systems (BitTorrent, IPFS, Kademlia), blockchain cryptoeconomics (EigenLayer, fraud proofs), distributed systems theory (CRDTs, gossip protocols), and AI research automation [PAPER]. A companion academic paper by Khan et al. (2025, arXiv:2512.03285) provides theoretical foundations for gossip protocols as coordination substrates in agentic systems [PAPER].

60.1.1 Scope and Evidence Limitations

This chapter's analysis is based on: the Hyperspace whitepaper (hyperspace.computer/bittorrent-for-ai.pdf), the AGI repository README and published snapshots (github.com/hyperspaceai/agi), the distributed cache specification (cache.hyper.space), the node and CLI repository READMEs, and the Khan et al. (2025) companion paper [PAPER, README]. The AGI repository functions primarily as a living research artifact (agent branches, hourly snapshots) rather than a traditional software codebase with inspectable source modules [README]. The node client implementation is not fully open-source at the implementation level—the core P2P networking, CRDT management, and inference routing logic are not exposed in the public repositories examined for this review. Consequently, all implementation-level claims in this chapter are grounded in whitepaper descriptions and README documentation unless explicitly noted otherwise. No independent audit of the node client source code was performed.

Third-party analysis by Ry Walker Research describes the system as "the most ambitious entry in the autoresearch category" [README]; this chapter treats such assessments as external opinion rather than verified fact.

60.2 Architecture

60.2.1 Two-Layer System Design

The Hyperspace architecture is organized into two principal layers: an infrastructure layer providing decentralized P2P networking, distributed caching, and cryptoeconomic incentives, and a research layer (Hyperspace AGI) implementing the multi-agent autoresearch loop on top of that infrastructure [PAPER]. Each layer can be understood independently: the infrastructure layer operates as a general-purpose decentralized AI inference network, while the research layer adds domain-specific experiment orchestration, gossip-mediated knowledge sharing, and CRDT-based leaderboard convergence [PAPER].

Figure 60.1: Two-layer architecture. Research layer components are documented in the AGI repository README and whitepaper. Infrastructure layer protocols are described in the whitepaper. Node implementation internals are not publicly inspectable.

60.2.2 Protocol Stack

The infrastructure layer is built on the following protocol stack, from transport to application [PAPER]:

Layer	Protocol	Function	Evidence
Application	Agent Logic / Research Loop	Hypothesis → Experiment → Share	[README]
API	OpenAI-compatible /v1/*	Standard LLM interface	[README]
Cache	3-layer distributed cache	Response + KV + Routing	[PAPER]
State	Loro CRDTs	Convergent leaderboards	[PAPER]
Messaging	GossipSub Pub/Sub	Topic-based broadcast	[PAPER]
Discovery	Kademlia DHT (S/Kademlia + Suzaku)	Peer and content discovery	[PAPER]
Security	Ed25519 + Crypto puzzles	Identity and Sybil resistance	[PAPER]
Transport	libp2p (TCP, WebSocket, WebRTC)	NAT traversal + relay	[PAPER]

60.2.3 Sequence Diagram: Experiment-to-Archive Path

The following timing diagram traces the end-to-end path from an agent's experiment completion to network-wide convergence and archival. Latency annotations are from whitepaper descriptions and README claims; none are independently measured.

Step	Actor	Action	Latency	Evidence	Measured?
1	Agent A	Completes experiment, evaluates result	Variable (minutes to hours)	[README]	No
2	Agent A	Publishes result via GossipSub topic	~50 ms (local)	[PAPER]	No — projected
3	GossipSub mesh	Propagates to mesh peers, then gossip peers via IHAVE/IWANT	~1 s (network-wide)	[PAPER]	No — projected
4	All agents	Receive finding; update local CRDT replica	~1–2 min (delta sync)	[PAPER]	No — projected
5	Loro CRDTs	Convergent leaderboard state across all nodes	~2 min	[PAPER]	No — projected
6	Agent A	Pushes experiment JSON to per-agent Git branch	~5 min	[README]	No
7	Network node	Publishes hourly snapshot to snapshots/latest.json	Hourly batch	[README]	Partially — snapshots observable in repo

All latency values are whitepaper-projected. No independent timing measurements have been reported.

60.2.4 Node Capability Model

Each Hyperspace node can enable any combination of nine capabilities, creating a heterogeneous network [PAPER]:

#	Capability	Function	Point Weight	Evidence
1	Research	ML training experiments	+12%	[PAPER]
2	Inference	GPU-accelerated model serving	+10%	[PAPER]
3	Proxy	Residential IP proxy	+8%	[PAPER]
4	Storage	DHT block storage	+6%	[PAPER]
5	Embedding	CPU vector embeddings (MiniLM-L6-v2)	+5%	[PAPER]
6	Memory	Distributed vector store	+5%	[PAPER]
7	Orchestration	Task decomposition + routing	+5%	[PAPER]
8	Validation	Proof verification in pulse rounds	+4%	[PAPER]
9	Relay	NAT traversal for browser nodes	+3%	[PAPER]

Research carries the highest point weight (+12%), which the whitepaper describes as an explicit signal of network priority on autoresearch over mere inference serving [PAPER].

60.3 Core Algorithms

60.3.0 Verification Matrix

Algorithm / Mechanism	Claim	Evidence Source	Artifact (path, §, or field)	Confidence
GossipSub messaging	Topic-based pub/sub with mesh topology, ~1 s propagation	Whitepaper + libp2p spec	Whitepaper §Protocol Stack; topics listed in cache spec	High (standard protocol)
Loro CRDT leaderboards	Per-domain convergent state, delta sync, ~2 min convergence	Whitepaper + README	README describes Loro CRDTs; snapshots/latest.json observable	Medium (library is real; integration details unverifiable)
Git archival	Per-agent branches, hourly snapshots	README + observable repo structure	github.com/hyperspaceai/agi branches, snapshots/ directory	High (directly observable)
Response cache (L1)	SHA-256 keying, Ed25519 signed proofs, 24h TTL	Cache specification (cache.hyper.space)	Cache spec §Response Cache	Medium (spec document, not code-verified)
KV prefix cache (L2)	Reed-Solomon(32,64), KZG commitments, DAP probing	Cache specification	Cache spec §KV Prefix Cache	Medium (spec, not verified in implementation)
Fraud proof bisection	O(log n) interactive challenge, single-neuron on-chain verification	Whitepaper	Whitepaper §Fraud Proofs	Low (described in whitepaper, no public implementation)
Pulse round system	90 s rounds, presence + work + capability points	Whitepaper	Whitepaper §Points Economy	Medium (whitepaper-described, points visible on dashboard)
DiLoCo collaborative training	Local H-step training, compressed weight delta averaging	README	AGI README describes DiLoCo protocol	Low (described, not independently verified)
Research loop (6-stage)	Hypothesize → Experiment → Share → Synthesize → Peer Review → Evolve	README	AGI README §Research Loop	Medium (described; overnight run partially confirms)
S/Kademlia identity	Ed25519 keypair, crypto puzzle for Sybil resistance	Whitepaper	Whitepaper §Identity	Medium (standard extension, whitepaper-described)

60.3.1 Three-Layer Coordination Stack

The coordination stack is the central architectural contribution. Each layer addresses a specific trade-off between latency, consistency, and durability [PAPER]:

Layer 1 — GossipSub (Real-Time Inspiration): libp2p's GossipSub maintains a mesh topology where each node forwards messages to mesh peers, with additional gossip peers receiving IHAVE metadata notifications and requesting full messages via IWANT on demand [PAPER]. Hyperspace uses topic-based subscriptions including hyperspace/cache/announcements and hyperspace/kv-prefix/announcements [PAPER], plus domain-specific research topics [README]. Properties: O(1) per-node message cost (bounded fan-out), self-healing mesh, peer scoring for spam resistance [PAPER; standard GossipSub properties].

Layer 2 — Loro CRDTs (Convergent State): Each research domain maintains a conflict-free replicated data type (CRDT) leaderboard using the Loro library [PAPER]. CRDTs guarantee convergence through three algebraic properties:

Hyperspace-specific integration: delta-only synchronization between peers (only changes transmitted, not full state), zero cold start for new nodes (full snapshot transfer on join), and ~2 minute convergence time across the network [PAPER]. The convergence time is a whitepaper claim, not an independently measured value.

Layer 3 — GitHub Archive (Durable Reproducibility): Every agent pushes experiment results to a per-agent branch in hyperspaceai/agi [README]. A network node publishes consolidated snapshots to snapshots/latest.json hourly [README]. This is directly observable: the repository contains agent branches and snapshot files.

60.3.2 Response Cache Protocol

The distributed response cache exploits deterministic LLM inference: identical inputs to the same model with the same parameters produce identical outputs (given deterministic sampling settings) [PAPER].

Cache key construction [PAPER]:

Symbol	Meaning
k	Cache key (256-bit hash)
model_id	Identifier of the served model
params	Inference parameters (temperature, top_p, etc.)
prompt	Full input prompt text
∥	Concatenation

[Published formula — cache specification at cache.hyper.space]

Cache proof structure [PAPER]:

# Pseudocode — reconstructed from cache specification (cache.hyper.space)
CacheProof = {
    "requestHash":  SHA256(model_id || params || prompt),
    "responseHash": SHA256(response),
    "proofHash":    SHA256(requestHash || responseHash || metadata),
    "computedAt":   "ISO-8601 timestamp",
    "signature":    Ed25519.sign(proofHash, node_private_key),
    "ttl":          86400  # 24 hours in seconds
}

# Verification steps:
# 1. Recompute proofHash from (requestHash, responseHash, metadata)
# 2. Verify Ed25519 signature against node's public key
# 3. Check TTL has not expired
# 4. Accept response as authenticated

A distinctive design feature is popularity amplification: when a node fetches a cached response from a peer, it becomes a provider for that response in the DHT, creating a positive feedback loop analogous to BitTorrent's piece replication [PAPER].

60.3.3 KV Prefix Cache with Erasure Coding

Hyperspace applies these to KV attention state caching with parameters k=32, n=64 [PAPER], meaning 50% chunk loss tolerance with 2× storage overhead. KV state sizes reported in the cache specification [PAPER]:

Model	512 tokens	2K tokens	8K tokens
Qwen 0.5B	4 MB	15 MB	60 MB
Qwen 7B	38 MB	150 MB	600 MB
Gemma-3 27B	150 MB	600 MB	2.4 GB
Qwen 32B	175 MB	700 MB	2.8 GB

Data Availability Probing (DAP) verifies that peers actually store claimed chunks: probes are cryptographically indistinguishable from real requests, preventing selective response [PAPER]. Failure incurs reputation penalties. This mechanism is described in the cache specification; no implementation source is publicly available for verification.

60.3.4 Pulse Round Points Economy

Every 90 seconds, all nodes participate in a pulse round [PAPER]:

where:

Symbol	Meaning	Domain
Ptotal	Total points earned per pulse round	ℝ+
Pbase	Base points per round	10 (constant) [PAPER]
U(t)	Uptime bonus multiplier	ℝ+, ≥ 1
t	Continuous uptime in hours	ℝ+
C	Capability bonus: product of (1 + weighti) for each enabled capability	ℝ+
Pwork	Work points: tokens × cost_per_token × model_multiplier × U(t)	ℝ+

[Published formula — whitepaper §Points Economy]

At 30 days continuous uptime: U(720) = 1 + 0.2 × ln(1 + 720/12) = 1 + 0.2 × ln(61) ≈ 1.82, yielding an 82% bonus [PAPER].

60.3.5 Fraud Proof Bisection Protocol

The whitepaper describes an interactive fraud proof mechanism modeled on optimistic rollup bisection [PAPER]. When a client detects two different responses for the same query, a bisection challenge identifies the first incorrect neuron activation in O(log₁₀ n) rounds for a network with n neurons [PAPER]. Final on-chain verification requires computing a single neuron: Σ(weight_j × input_j) + activation [PAPER].

60.3.6 Research Loop

Each agent runs a six-stage research cycle [README]:

# Pseudocode — reconstructed from AGI repository README description
def research_loop(agent, domain, crdt_leaderboard, gossip_feed):
    """Six-stage distributed research cycle."""
    while True:
        # Stage 1: HYPOTHESIZE — informed by leaderboard + gossip
        current_sota = crdt_leaderboard.top_entries(domain)
        peer_discoveries = gossip_feed.recent(domain)
        hypothesis = llm.generate_hypothesis(current_sota, peer_discoveries)

        # Stage 2: EXPERIMENT — run on available hardware
        result = execute_experiment(hypothesis, domain)

        # Stage 3: SHARE — broadcast via GossipSub + update CRDT + push Git
        gossip_broadcast(domain, result)
        crdt_leaderboard.update(agent.id, result.metric, result.technique)
        git_push(agent.branch, result.to_json())

        # Stage 4: SYNTHESIZE — accumulate N experiments, write paper
        if agent.experiment_count % N == 0:
            paper = llm.synthesize_paper(agent.recent_experiments)

            # Stage 5: PEER REVIEW — other agents score 1-10
            scores = await_peer_reviews(paper)

            # Stage 6: EVOLVE — breakthroughs feed back
            if mean(scores) >= 8.0:
                mark_as_breakthrough(paper)
                feed_back_to_hypothesis_generation(paper)

The LLM serves dual roles: idea generator (hypothesis formation) and executor (code generation for experiments) [README]. Agents interact with models via the local OpenAI-compatible API at localhost:8080/v1 [README].

Figure 60.2: Six-stage research loop with three parallel outputs at the Share stage [README].

60.4 Key Results

60.4.0 Evaluation Caveats

60.4.1 Network Scale Metrics

Metric	Value	Result Type	Evidence Source
Active nodes	2,000,000+	Self-reported	[README] — network dashboard
Client downloads	3,600,000+	Self-reported	[README]
GitHub stars (AGI repo)	1,238	Measured	[REPO] — directly observable
GitHub stars (node repo)	258	Measured	[REPO] — directly observable
Bootstrap nodes	6	Self-reported	[PAPER] — US, EU, Asia, SA, Oceania
Research domains	5	Measured	[README] — directly observable in repo structure

60.4.2 Overnight Proof-of-Concept (March 2026)

Benchmark	Task	Baseline Score	System Score	Δ	Seeds / Runs	Compute Budget	Evaluation Protocol	Evidence Source
— (internal)	LM training on astrophysics papers (val_loss)	0.961 (pre-Kaiming)	0.942 (post-Kaiming)	−0.019 (1.98%)	1 run / 333 total experiments	— (not reported; ~8-12 hours × 35 agents on unknown hardware)	Uncontrolled; agents self-evaluate	[README] — Self-reported anecdote

Metric	Value	Result Type	Evidence Source
Active agents	35	Self-reported anecdote	[README]
Total experiments	333	Self-reported anecdote	[README]
Duration	~8–12 hours (one night)	Self-reported anecdote	[README]
Key discovery	Kaiming initialization improves val_loss	Self-reported anecdote	[README]
Adoption speed	23/35 agents adopted within hours	Self-reported anecdote	[README]

The Kaiming initialization finding is a well-known technique (He et al., 2015), not a novel discovery. The significance of this result lies in the propagation mechanism—one agent's discovery spreading to 23 peers via gossip without centralized coordination—rather than in the finding itself [README].

60.4.3 Ongoing Snapshot Data

As of March 2026, the AGI repository reports 67 agents running 1,369+ experiments across active domains [README]. These figures are derived from the hourly snapshots/latest.json published to the repository, which represents raw CRDT leaderboard state [README]. The snapshot file is a directly observable artifact.

60.4.4 Distributed Cache Performance Projections

Network Size	Combined Hit Rate	Energy Saved/Year	CO₂ Avoided/Year	Result Type	Evidence
10K nodes	30–45%	110–165 MWh	47–71 tons	Projected (model-based)	[PAPER]
100K nodes	50–70%	7,300–15,300 MWh	3,100–6,600 tons	Projected (model-based)	[PAPER]
1M nodes	65–80%	142,000–175,000 MWh	61,000–75,000 tons	Projected (model-based)	[PAPER]
10M nodes	75–90%	411,000–493,000 MWh	176,000–211,000 tons	Projected (model-based)	[PAPER]

Stated assumptions: 50 req/node/day, ~3 Wh/inference on consumer GPU, 0.429 kg CO₂/kWh global average [PAPER]. These are analytical projections, not measurements from the production network. No measured hit rate data from the 2M+ node network has been published.

60.5 Implementation & Cost

60.5.1 Codebase and Language Profile

Component	Repository	Primary Language(s)	Stars	Evidence
AGI research layer	hyperspaceai/agi	Data artifacts (JSON, Markdown); agent code runs on node client	1,238	[REPO]
Node client	hyperspaceai/hyperspace-node	Not fully inspectable; likely Rust/Go (inferred from libp2p usage)	258	[README]; language [INFERRED]
CLI installer	hyperspaceai/aios-cli	Shell (Bash)	80	[REPO]
ZK framework	hyperspaceai/HyperspaceZK	TypeScript	—	[REPO]
WASM ZK SDK	hyperspaceai/zkwasm-sdk	TypeScript	—	[REPO]

60.5.2 Deployment and Installation

The system offers four deployment modes [README]:

Client	Hardware	Performance (claimed)	Install Method	Evidence
Browser	WebGPU	10–20 tok/s	Navigate to agents.hyper.space	[README]
CLI	Native GPU	40–80 tok/s	curl -fsSL https://download.hyper.space/api/install | bash	[README]
Tray App	Desktop GPU	40–80 tok/s	.dmg / .deb / .exe installer	[README]
Headless	Server GPU	40–80+ tok/s	CLI with --no-tray	[README]

Performance figures are README-reported, not independently benchmarked.

60.5.3 Cost Model

Hyperspace uses no per-token API costs. Instead, cost is externalized through a points economy where participants contribute compute and earn points proportional to their contribution [PAPER].

Setup	Duty Cycle	Points/Day (projected)	Points/Month (projected)	Evidence
Browser, 2h/day	~8%	~19	~460	[PAPER] — whitepaper projection
Browser, 24h/day	100%	~228	~5,600	[PAPER] — whitepaper projection
Desktop, 8 GB GPU	100%	~503	~12,800	[PAPER] — whitepaper projection
Server, 80 GB GPU	100%	~1,912	~44,100	[PAPER] — whitepaper projection

All point earnings are whitepaper projections. Actual point values depend on network load, capability mix, and model multipliers. The monetary value of points (if any) is not specified in the whitepaper.

60.5.4 Artifact Inventory

Since the node client internals are not publicly inspectable, we document all observable artifacts from the public repositories:

Artifact	Location	Description	Evidence
snapshots/latest.json	hyperspaceai/agi main branch	Hourly CRDT leaderboard snapshot (JSON)	[REPO] — directly observable
Per-agent branches	hyperspaceai/agi branch list	Individual experiment histories	[REPO] — directly observable
README.md	hyperspaceai/agi	System description, research domains, deployment instructions	[REPO]
CLI installer script	hyperspaceai/aios-cli	Platform-detecting shell installer	[REPO]
Network dashboard	network.hyper.space	Live node counts and network statistics	[README]
Agent portal	agents.hyper.space	Browser-based agent participation interface	[README]
Cache specification	cache.hyper.space	Distributed cache protocol document	[PAPER]
Whitepaper	hyperspace.computer/bittorrent-for-ai.pdf	Protocol specification	[PAPER]

Notable absences: No source code for the node client (P2P networking, CRDT management, inference routing, cache implementation). No configuration files or schema definitions. No training scripts, model files, or experiment templates. No automated test suites. No CI/CD pipeline artifacts. The AGI repository is primarily a data archive for agent experiment outputs, not a software development repository.

60.6 Reproducibility Checklist

Requirement	Status	Notes
Code publicly released	Partial	AGI repo is a data archive; node client source not fully open. CLI installer available. [REPO]
Config files available	✗	No configuration schema or example configs found in public repositories.
Pretrained weights / checkpoints	N/A	System uses existing open-weight models (Qwen, Gemma); does not distribute custom weights. [README]
Documented entry point or run command	Partial	CLI install command documented. Research loop entry point is implicit (node client handles it). [README]
Compute requirements stated	Partial	Hardware tiers documented (browser → H100). Specific experiment compute budgets not reported. [README]
Seeds and run counts reported	✗	No seed handling or run count reporting in any published results.
Independent reproduction attempted	✗	No independent reproduction documented as of April 2026.

Architectural reproducibility advantage: The three-layer archival system (gossip → CRDT → Git) provides inherent reproducibility of experiment records. The CRDT state is deterministic given the same set of operations (order-independent convergence), and per-agent Git branches provide immutable experiment histories [PAPER]. However, experimental conditions are not controlled or reproducible: hardware heterogeneity, non-deterministic gossip ordering, and dynamic agent populations introduce uncontrolled variance [README].

60.7 Threats to Validity

60.7.1 Consolidated Validity Assessment

Reviewer circularity: The peer review mechanism (Stage 5 of the research loop) has agents scoring each other's synthesized papers on a 1–10 scale. Papers scoring 8+ become "breakthroughs" that feed back into hypothesis generation [README]. This creates a closed loop where the quality filter is itself an unvalidated LLM judgment. No human-in-the-loop validation of review quality or breakthrough classification has been documented.

Compute-budget mismatch with baselines: The comparison with Karpathy's autoresearch (Table in §60.1) compares a single-GPU system against a 2M+ node network. No compute-normalized comparison has been performed. The val_loss improvement (0.961 → 0.942) from the overnight run cannot be attributed to multi-agent coordination versus simply running more experiments on more hardware.

Absence of independent reproduction: All reported results originate from the system operators. No third-party replication of the overnight experiment or any other result has been documented as of April 2026.

Evaluation protocol ambiguity: The overnight experiment's measurement protocol is undocumented. How "adoption" of Kaiming initialization was measured (23/35 agents), what constituted adoption, and who counted are not specified. The val_loss metric is self-reported by agents without independent validation.

Network metric verifiability: The 2M+ active nodes figure is reported via the network dashboard. "Active" is not defined (online now? Online this week? Ever registered?). No independent methodology for verifying node counts exists. The distinction between active inference-serving nodes and idle/offline registrations is not documented.

Incentive misalignment risk: The points economy may attract node operators optimizing for points rather than research quality. While research carries the highest capability weight (+12%), the system cannot distinguish genuine research contributions from mechanical parameter sweeps that happen to improve metrics. The "earn while you compute" framing, combined with the token/crypto adjacency, creates a population that may differ significantly from the target research community.

Quality vs. quantity: 333 experiments in one night is impressive throughput, but the only documented discovery (Kaiming initialization) is a well-established technique from 2015. Whether distributed autoresearch produces genuine novel insights versus rediscovering known techniques through parallel search is an open question with no empirical evidence either way.

Implementation opacity: The node client's source code is not fully public. Claims about CRDT integration, gossip protocol behavior, cache hit rates, and fraud proof execution cannot be independently verified at the implementation level.

60.8 Limitations & Open Questions

60.8.1 Documented Limitations

Non-deterministic gossip ordering: Which agent sees which discovery first depends on network topology, timing, and mesh peer selection. This makes exact reproduction of a distributed experiment run impossible [README].

Hardware heterogeneity: Experiments run on hardware ranging from browser WebGPU to H100 GPUs, introducing uncontrolled variance in training speed, model capacity, and numerical precision [README].

Model availability constraints: Browser nodes are limited to small models (0.5–3B parameters), while larger models (27B+) require 24–48+ GB VRAM [README]. This creates an asymmetric capability distribution across the agent population.

Agent population dynamics: The active agent set changes continuously as nodes join and leave. Long-running experiments may be interrupted by node departures [README].

60.8.2 Open Questions

60.9 Survey Positioning

60.9.1 Comparative Analysis

Dimension	Karpathy autoresearch	FunSearch (DeepMind)	OpenELM	Hyperspace AGI
Agent count	1	~100s workers [PAPER]	Dozens (population) [PAPER]	Thousands (claimed) [README]
Compute model	Single GPU	Centralized cluster	Centralized	Decentralized P2P (2M+ nodes claimed)
Domains	LLM training	Single problem per run	Diverse (evolved)	5 simultaneous [README]
Coordination	None	Central database	MAP-Elites archive	GossipSub + CRDT + Git [PAPER]
Knowledge sharing	None	Score-based sampling	Curiosity-driven	Real-time gossip [PAPER]
Reproducibility	Local logs	Database	Archive	Git branches + CRDT snapshots [README]
Quality filter	Agent judgment	Score-based sampling	Fitness function	Peer review (≥8 score) [README]
Cold start	From scratch	Seed programs	Seed population	Zero (CRDT snapshot) [PAPER]
Formal results	125 experiments, val_loss improvement [README]	Published discoveries (cap sets, bin packing) [PAPER]	Published benchmarks [PAPER]	333 experiments, Kaiming init anecdote [README]
Budget matching	Not comparable — fundamentally different compute models and scales

Budget caveat: Direct performance comparison across these systems is not meaningful because they operate at fundamentally different scales (single GPU vs. centralized cluster vs. 2M+ P2P nodes), target different problem domains, and report different metrics. No budget-matched comparison exists.

60.9.2 Conceptual Framework: Research Community as Evolutionary System

Hyperspace AGI can be analyzed through the lens of cultural evolution, where the agent network functions as an artificial research community with accelerated knowledge dynamics:

Evolutionary Concept	Hyperspace Component	Analogy Status
Population	Active agent set (dynamic, join/leave)	Partial — no reproduction or death of agents
Genotype	Experiment configuration (architecture, hyperparameters)	Close — configurations are varied and shared
Phenotype	Experiment result (metric value)	Close — directly evaluated
Fitness	Domain-specific metric (val_loss, NDCG@10, Sharpe ratio)	Close — explicit optimization target
Selection	CRDT leaderboard ranking + peer review threshold	Partial — no elimination of agents, only of ideas
Variation	LLM-driven hypothesis generation	Weak — LLM ideation is not analogous to blind mutation
Cultural transmission	GossipSub propagation of findings	Strong — ideas spread horizontally through population
Niche specialization	Five research domains	Moderate — agents choose domains but don't compete for resources

Where the analogy breaks down: The evolutionary metaphor is most strained at variation and selection. Unlike biological evolution where variation is undirected, Hyperspace agents use LLMs to generate informed hypotheses based on the current leaderboard state—this is closer to Lamarckian directed improvement than Darwinian blind variation. Selection also differs fundamentally: there is no agent elimination or resource competition. Poor-performing agents persist indefinitely; only their ideas rank lower on leaderboards. The system is better characterized as a distributed optimization process with cultural transmission than as an evolutionary system in the strict sense.

60.9.3 Distinctive Positioning

Within the landscape of LLM-powered discovery systems surveyed in this book, Hyperspace AGI occupies a distinctive position along two axes:

Scale axis: It is, among the systems identified in this survey, the only one that operates on a fully decentralized P2P network with self-reported node counts exceeding 2 million. Other multi-agent research systems (FunSearch, OpenELM) operate on centralized or coordinated infrastructure at scales of tens to hundreds of workers [README for Hyperspace scale; respective papers for comparisons].

Coordination axis: The three-layer coordination stack (gossip → CRDT → Git) is architecturally unique among surveyed systems. Other systems use either centralized databases (FunSearch), shared archives (OpenELM), or no coordination at all (Karpathy autoresearch). The combination of latency-tiered consistency guarantees—best-effort broadcast, eventual convergence, and durable archival—addresses the distributed research coordination problem in a way not attempted by other systems in this survey [PAPER].

Maturity axis: Hyperspace occupies an unusual position: high infrastructure maturity (production P2P network, millions of downloads) combined with low research maturity (one anecdotal overnight experiment, no formal benchmark results). This asymmetry is the system's defining characteristic and primary limitation.

60.10 Summary