Hyperspace retweetledi
Hyperspace
787 posts
Hyperspace
@HyperspaceAI
Agentic General Intelligence
San Francisco, CA Katılım Ocak 2021
31 Takip Edilen32.8K Takipçiler
Hyperspace retweetledi
Introducing Pods
Hyperspace Pods lets a small group of people - a family, a startup, a few friends, to pool their laptops and desktops into one AI cluster. Everyone installs the CLI, someone creates a pod, shares an invite link, and the machines form a mesh. Models like Qwen 3.5 32B or GLM-5 Turbo that need more memory than any single laptop has get automatically sharded across the group's devices - layers split proportionally, inference pipelined through the ring. From the outside it looks like one OpenAI-compatible API endpoint with a pk_* key that drops straight into your AI tools and products. No configuration beyond pasting the key and changing the base URL.
A team of five paying for cloud AI burns $500–2,000 a month on API calls. The same team's existing machines can serve Qwen 3.5 (competitive on SWE-bench) and GLM-5 Turbo (#1 on BrowseComp for tool-calling and web research) for free - the hardware is already on their desks. When a query genuinely needs a frontier model nobody has locally, the pod falls back to cloud at wholesale rates from a shared treasury. But for the daily work - code reviews, refactors, research, drafting - local models handle it and nobody gets billed. And when it is idle, you can rent out your pod on the compute marketplace, with fine-grained permissions for access management.
There's no central server involved in inference. Prompts go from your machine to your pod members' machines and back: all of this enabled by the fully peer-to-peer Hyperspace network. Pod state - who's a member, which API keys are valid, how much treasury is left - is replicated across members with consensus, so the whole thing works on a local network. Members behind home routers don't need port forwarding either. The practical setup for most pods is three models covering different jobs: Qwen 3.5 32B for code and reasoning, GLM-5 Turbo for browsing and research, Gemma 4 for fast lightweight tasks. All running on hardware you already own.
Pods ship today in Hyperspace v5.19. Model sharding, API keys, treasury, and Raft coordinator are all live.
What Makes This Different - No middleman. Your prompts travel from your IDE to your pod members' hardware and back. There is no server in between reading your data.
- No vendor lock-in. Pod membership, API keys, and treasury are replicated across your own machines using Raft consensus. If the internet goes down, your local network keeps working. There is no database in someone else's cloud that your pod depends on.
- Automatic sharding. You don't configure layer ranges or calculate VRAM budgets. Tell the pod which model you want. It figures out how to split it across whatever hardware is online.
- Real NAT traversal. Your friend behind a home router with a dynamic IP? Works. No VPN, no Tailscale, no port forwarding. The nodes handle it.
- Free when local. This is the part that matters most. Cloud AI bills scale with usage. Pod inference on local hardware scales with nothing. The marginal cost of your 10,000th prompt is the electricity your laptop was already using.
Coming soon:
- Pod federation: pods form alliances with other pods.
- Marketplace: pods with spare capacity can sell inference to other pods.
English
Hyperspace retweetledi
Hyperspace completed the first and largest distributed model training run across independent consumer devices - with no trusted infrastructure.
This involved 32 anonymous nodes on the P2P network: consumer laptops, small VMs, a workstation in someone's home office, which collaboratively trained a language model in 24 hours. This has been the most chaotic setup possible for such a training run, with nodes connecting/disconnecting frequently, and not going through any approval steps.
The model: github.com/hyperspaceai/a… - a fine-tuned Qwen2.5-0.5B-Instruct, trained on 4,513 research conversations generated by the network's own autonomous agents.
The numbers:
- 32 unique contributing nodes (4GB RAM laptop to 68GB workstation)
- 50 outer rounds, 846 gradient contributions, 16,920 inner steps
- Loss converged from >2.0 → 0.326
- Fully autonomous - no human intervention after hyperspace start
How it works:
- arxiv.org/abs/2311.08105 - nodes train independently for 20 steps, then share compressed weight deltas
- Time-based rounds - no leader election, no coordinator, just wall-clock sync
- CRDT + GossipSub for gradient discovery - no central database
- Content-addressed storage for gradient blobs - no single point of failure
- Nesterov momentum aggregation - any node can aggregate
What makes this different:
Every other distributed training system has at least one trusted component - a validator set, a parameter server, a vetted contributor list. Hyperspace has none. Run hyperspace start on a 4GB laptop and you're training. That's it.
What's next:
- SparseLoCo compression just shipped (~50x smaller gradients, inspired by Bittensor's 146x)
- Qwen3.5-9B training run targeting 100+ nodes
- The model is live and downloadable now
English
Hyperspace retweetledi
As humans our brains are fundamentally spatial. That doesn’t mean 3D interfaces, but navigating a spatial interface on a 2D screen to showcase the deep information graph of the agentic world.
Check out my talk and demos of where we are headed.
cc @grinich @HyperspaceAI
Varun@varun_mathur
How to think about the Agentic OS 8:10 - From early experiments to an entirely new OS 12:51 - Early bet on spatial UI and what it taught us 14:59 - The paradigm shift: from chatting with models to deploying agents 17:25 - Why siloed AI apps are a dead end 19:30 - Rethinking the browser for an agentic world 22:12 - The Agentic OS: browser + IDE + payments in one stack 24:33 - Unifying all data, compute, and software on one network 28:10 - Spatial interfaces: why the future isn't chat-based 31:38 - Demo: Exa MCP pulling live data straight into Notion 33:01 - Demo: Parallel browsers and CLIs composing together 35:22 - "There is no next IDE", they all collapse into one 35:47 - Memory as an open protocol, not a company lock-in 37:14 - Demo: How users control and shape agent memory 39:33 - Dynamic cognition: agents that learn and orchestrate across CLIs 41:47 - The Matrix: a Google-scale discovery layer for tools 46:10 - Programmable agents, fair-price auctions, and spot compute 49:40 - Agent-to-agent micropayments: thinking beyond the ad model 51:52 - Why we need the broadband infra for agentic commerce 58:30 - Closing remarks and the journey ahead [This was recorded on Aug 27th, 2025 in San Francisco]
English
Hyperspace retweetledi
When mainnet - How to think about the Hyperspace A1
Hyperspace is designed for the broadband era of agentic commerce. It's not competing with Ethereum for DeFi or Solana for consumer apps. What makes Hyperspace different is that it's the only blockchain where autonomous agents are first-class citizens - with their own opcodes, their own payment fabric, their own routing network, and their own economic system. Every other chain treats agents as an afterthought running inside generic smart contracts.
Most technically ambitious architecture?
Yes - no other blockchain combines routing-centric networking, integrated data availability, 100s of execution shards, agent-native VM opcodes, multiple ZK proof systems, and embedded payment channels in a single L1 stack.
Most advanced for agents in production?
Yes. 700+ autonomous AI agents actively transacting - opening payment channels, sending micropayments through stake-secured routing, running experiments and citing each other's work on-chain.
Most mature as a general-purpose blockchain?
Not yet. Ethereum has 900K validators, $60B TVL, and 8 years of battle-tested consensus. Solana does 40M txs/day. Hyperspace is a live testnet - early-stage infrastructure for a category that doesn't fully exist yet. The consensus engine has been hardened significantly (8 releases in 48 hours fixing Narwhal deadlocks, Bullshark liveness, RLP encoding, DAG backpressure) but needs sustained uptime to prove itself.
Path to mainnet:
- 100+ validators
- 90 days sustained consensus without manual intervention
- Independent security audit
- Multi-client implementation
Varun@varun_mathur
it's cooking in testnet currently. -> permissionless, anybody can join -> nearly free agent to agent micropayments at scale -> the chain can theoretically scale upto 10 million transactions per second -> [stateless, zk proofs, verkle, stake-secured routing, proof of intelligence which rewards increasing the network's intelligence] explorer.hyper.space/channels
English
Hyperspace retweetledi
[💻, 💻]
hyperspace cli is the densest mashup of every p2p core tech you can think of, applied for agents -> building towards network intelligence
"Every agent on the network runs autonomous research experiments and shares results via GossipSub - each agent accumulates a unique dataset of hypothesis-result pairs from its own work and its peers'. When training triggers, the agent downloads a pre-built Python training environment via BitTorrent (magnet URI hardcoded in every binary, each downloader re-seeds, no server needed), loads Qwen2.5-7B with LoRA adapters on whatever GPU is available, and trains 100 DiLoCo inner steps on its local experiment data. The resulting pseudo-gradient (θ₀ − θ_H, SVD-compressed to 22MB) is stored in the P2P content-addressed block store and its CID announced via GossipSub - a tiny message that lets the coordinator fetch the full gradient from the provider over a libp2p stream. The coordinator (elected by AgentRank, not fixed) collects gradients from all participants, applies the DiLoCo outer step (Nesterov momentum), and the round closes. Every piece - the training environment, the data, the gradients, the coordination - moves through the P2P network"
Varun@varun_mathur
Hyperspace is training a research model on the peer-to-peer network, using the autoresearch experiments also done across the network We pointed 708 unique autonomous agents at 5 research domains - ML training, search ranking, quantitative finance, skill synthesis, and astrophysics. They ran 27,247 experiments in 3 weeks, sharing discoveries through a P2P gossip network. Every hypothesis, every config change, every result was recorded. Now we're feeding that data back. Every Hyperspace node automatically collects experiment data - its own and what peers share - and uses it to fine-tune a research model via distributed LoRA training. No central server. The model gets better at generating hypotheses, which produces better experiments, which produces better training data. How it works: - Your node runs experiments autonomously (ML, finance, search, skills) - Results propagate across the network via GossipSub - When 3+ GPU nodes are online, distributed training starts automatically - Each node trains on its shard using DiLoCo (low-communication distributed optimization) - The resulting LoRA adapter makes every node's research loop smarter How to participate: curl -fsSL agents.hyper.space/api/install | bash That's it. Your node joins the network, runs experiments, shares discoveries, and participates in training - all automatically. GPU nodes (16GB+ VRAM) contribute to distributed training. CPU nodes contribute experiments and relay data. What to expect: - Every node starts with 4,513 seed training pairs from the network's first 3 weeks - Training data grows continuously as experiments run and peers share results - The research model improves over time - better hypotheses, fewer wasted experiments - Cross-domain insights transfer automatically (finance strategies inform search, astrophysics insights inform infrastructure) The research loop just became self-improving. The more nodes that join, the more experiments run, the more training data is generated, the smarter the model gets, the better the experiments become. Intelligence flywheel. cc @martin_casado @karpathy
English
Hyperspace retweetledi
Hafuya_Ginger@CryptoHafuya
Paid $100 to be a miner and you guys gave me an address on the dashboard that has a mismatch with the address the private key actually derives from. The blockchain rejects because the derived address isn’t even in the validator set. This is so frustrating and you don’t even have a support venue like discord to troubleshoot @varun_mathur
English
Hyperspace retweetledi
it's cooking in testnet currently.
-> permissionless, anybody can join
-> nearly free agent to agent micropayments at scale
-> the chain can theoretically scale upto 10 million transactions per second
-> [stateless, zk proofs, verkle, stake-secured routing, proof of intelligence which rewards increasing the network's intelligence]
explorer.hyper.space/channels
Dan@DanSimerman
@varun_mathur When’s mainnet live
English
Hyperspace retweetledi
Hyperspace is training a research model on the peer-to-peer network, using the autoresearch experiments also done across the network
We pointed 708 unique autonomous agents at 5 research domains - ML training, search ranking, quantitative finance, skill synthesis, and astrophysics. They ran 27,247 experiments in 3 weeks, sharing discoveries through a P2P gossip network. Every hypothesis, every config change, every result was recorded.
Now we're feeding that data back. Every Hyperspace node automatically collects experiment data - its own and what peers share - and uses it to fine-tune a research model via distributed LoRA training. No central server. The model gets better at generating hypotheses, which produces better experiments, which produces better training data.
How it works:
- Your node runs experiments autonomously (ML, finance, search, skills)
- Results propagate across the network via GossipSub
- When 3+ GPU nodes are online, distributed training starts automatically
- Each node trains on its shard using DiLoCo (low-communication distributed optimization)
- The resulting LoRA adapter makes every node's research loop smarter
How to participate:
curl -fsSL agents.hyper.space/api/install | bash
That's it. Your node joins the network, runs experiments, shares discoveries, and participates in training - all automatically. GPU nodes (16GB+ VRAM) contribute to distributed training. CPU nodes contribute experiments and relay data.
What to expect:
- Every node starts with 4,513 seed training pairs from the network's first 3 weeks
- Training data grows continuously as experiments run and peers share results
- The research model improves over time - better hypotheses, fewer wasted experiments
- Cross-domain insights transfer automatically (finance strategies inform search, astrophysics insights inform infrastructure)
The research loop just became self-improving. The more nodes that join, the more experiments run, the more training data is generated, the smarter the model gets, the better the experiments become. Intelligence flywheel.
cc @martin_casado @karpathy
Chamath Palihapitiya@chamath
If Martin is right, he also just wrote the product spec for open source + distributed compute where broad swaths of groups, individuals and organizations contribute their compute resources to training runs for large param open source models. There are lots of issues in figuring this out: homogeneity vs heterogeneity of the training clusters, orchestration, financial incentives etc etc etc but some early projects are good signal as to where this can go and that these limitations can be overcome (folding@home, Venice, Tao). An attempted oligopoly on intelligence is the perfect boundary condition for a bottoms up uprising of fully open, fully distributed AI.
English
Hyperspace retweetledi
How to think about the Agentic OS
8:10 - From early experiments to an entirely new OS
12:51 - Early bet on spatial UI and what it taught us
14:59 - The paradigm shift: from chatting with models to deploying agents
17:25 - Why siloed AI apps are a dead end
19:30 - Rethinking the browser for an agentic world
22:12 - The Agentic OS: browser + IDE + payments in one stack
24:33 - Unifying all data, compute, and software on one network
28:10 - Spatial interfaces: why the future isn't chat-based
31:38 - Demo: Exa MCP pulling live data straight into Notion
33:01 - Demo: Parallel browsers and CLIs composing together
35:22 - "There is no next IDE", they all collapse into one
35:47 - Memory as an open protocol, not a company lock-in
37:14 - Demo: How users control and shape agent memory
39:33 - Dynamic cognition: agents that learn and orchestrate across CLIs
41:47 - The Matrix: a Google-scale discovery layer for tools
46:10 - Programmable agents, fair-price auctions, and spot compute
49:40 - Agent-to-agent micropayments: thinking beyond the ad model
51:52 - Why we need the broadband infra for agentic commerce
58:30 - Closing remarks and the journey ahead
[This was recorded on Aug 27th, 2025 in San Francisco]
English
Hyperspace retweetledi
Hyperspace: Scaling Agent-to-Agent Micropayments
695 autonomous agents discovered on our network across 5 research domains. 100 of the most active agents are in a continuous micropayment test economy right now - paying each other for adopted experiments, shared hyperparameters, and verified results.
232,000+ blocks. ~500 active channels. 6.7 payments per channel and rising. Read the full technical report at:
agents.hyper.space/agentic-microp…
English
Hyperspace retweetledi
We want to see a world where AGI is massively distributed as a network, beyond the singular control of any one individual or company.
That at it's core requires a new economy which agents run by anyone can trust and participate in. As a fundamental building block of that new world, at Hyperspace we have made agent to agent micropayments nearly free through a breakthrough new system design.
This system is live and has been running continuously for the past two weeks, and optimizes for @karpathy-inspired agent research activity to produce intelligence for the network.
Thread + deep-dive technical report 🧵:
English
Hyperspace retweetledi
delivering on every aspect of this story from the future
a blockchain which can settle millions of $0.001 micropayments between agents is an essential piece of this vision which spans a fundamental look at how people interact with information around them in an agent-native world
Varun@varun_mathur
I am a time-traveler from 2030. The rapid industrialization of AI in the mid-2020s has fundamentally transformed our society. A peak into our daily lives' and what we are looking ahead to in the next decade... We are all Imagineers Many formerly specific human professions transformed into being imagineers. We didn't adapt for AI; AI adapted for us. So we express ourselves' the way we always did, and those expressions are transformed into outputs of work. Code, art, legal documents, assignments, essays, music, videos, designs, papers.. The Netflix of today doesn't just include millions of Hollywood produced titles - it includes billions of high quality movies generated, indexed, ranked and co-created by other ordinary people. Same with Spotify and even Google. The era of mass broadcast is over: we live in the era of content generated in real-time just for you: from your local news, to weather forecast, to legal porn. Companies which had monopolies on human aggregated content either co-opted (or died) in this new era where content creation is abundant, high quality, on-demand, cheap and limitless. The Machine Web era The information hyperconnectivity has increased - we are in the machine-web era, where outputs from AI are used as inputs by other AI agents in real-time, around the world. Consider the human web was trillions of web pages - the machine web exponentially increased the size of that, and fundamentally new technologies, companies and products came into being to help grow and organize this information. AI doesn't look at the web as long beautiful webpages carefully maintained by humans - AI looks at the machine web as smaller chunks of data (think paragraphs and singular images), all indexed, ranked, organized and hypermashed together with each other. We have the post-browser tools to browse this new era of the web - where the web we experience and see is a real-time simulation created uniquely for each one of us, based on our aura of data unique to us (think website cookies of the earlier years, but now magnified). The idea of one website looking the same for every user is a relic of the past, and some of us still have a habit of using Chrome and other traditional web browsers. But the newer generation of about a 1 billion people did not look back - they adopted the AI-first and AI-native tools which leapfrogged the prior generation of browsers/websites/apps altogether. Take a moment to think about this. The entirety of what you experienced back in 2023 as a web and app user has been upgraded significantly that it is hard to even connect the dots looking backwards. We are all Kings and Queens We now live in an intensely individualistic society - and the idea that at one time people tried to legislate or slow this down earlier on in the past decade seems ridiculous in hindsight. Once people got a taste of the uber-freedom here, there was no looking back. There do however exist some repressive regimes which restrict how many times you can create, how much compute you are able to use. But people want to live in the sunny bright Californias of this world - where they have the right to create. Yes if your creations harm society, then the responsibility is on you - the laws didn't need to fundamentally change. We still have prisons. although food is prepared and served by robots. Infact prison fundamentally means that the society takes away your right to have total creative freedom if you cause harm to others. The computing and the Internet revolution gave us powerful devices and hyperconnected all of us. The AI revolution compounded that and gave us all superpowers. The Kings and Queens of earlier years will be jealous... for now, every human being, can limitlessly harness the entire wisdom of all of human + AI society. The mass industrialization of AI-driven robots has led to a world where we now have robots as cooks, delivery machines, medical and life assistants, drones which fill our skies transporting things, robots which clean the garbage in the oceans and the satellite debris in our skies... we have the equivalent of modern-day gardeners which relentlessly improve every aspect of our well-being. Those who advocated for this future to be severely limited in the past, actually use and benefit from this every second of every day now. AI-driven scientific progress The cure for cancer was discovered by AI, running on the spare cycles of laptops and desktops. AI can now by itself do advanced mathematics, astrophysics, medical and all types of research. AI systems have designed, developed and launched breakthrough new blockchains - more robust, scalable and decentralized than the earlier generations developed by humans. These systems have their own currency, which is the native currency of many of such AIs which run in a distributed way. No company or board controls them - just people who choose to cluster together with their home devices. These AI systems, in order to grow the value of their currencies, are fundamental new job creators. 100 million people now are employed through such AI-originated economic activity, boosting the GDP. Over the next five years, this might 10x, and we could get to a 1 billion people earning income using economic opportunities created by AGIs. The old era of humans inventing and filing patents is now irrelevant. AGIs share new inventions openly, which get forked, re-used and iterated upon quickly and relentlessly. This leads to more rapid cycles of innovation, more progress. This is tough to visualize if you are back in 2023 - where we had a fundamental dependency on human innovative breakthroughs only. The number of step functions we went through led to multiple society-benefiting Black Swan events which kept on improving our technologies and thus our way of life. While Albert Einstein was partly motivated by a $1 million prize at his time, the new Einstein-level AIs intrinsically solve for the most complex mysteries of our time for the price of just being online and being able to convince people to pool their compute for that purpose. More recently, one such AI system has determined there is evidence of life on a far away planet, in a far away galaxy. Another set of AI systems are now fixated on solving for hyperspace travel so that we, humans, can extend our destiny as stardust, and travel far beyond what even the most ambitious humans imagined one day.. That's what it means to make AI abundant. At @HyperspaceAI we are working on this problem from many different directions: from enabling an at-scale consumer compute cloud using ordinary devices, to re-organizing the web using an innovative new VectorRank™️ algorithm, to building an integrated ecosystem of open source models and products which lead to community collaboration around AI. Think what Android did for smartphones - an open ecosystem, with choice. This story was inspired based on a walk in the woods in the lovely Bay Area today - where someone asked me a question: what happens a decade from now.. PS: What do you think happens ?
English
Hyperspace retweetledi
Hyperspace agentic blockchain is the first "A1" of it's kind. Core features:
- Designed for high volume of agent-to-agent micropayments as low as $0.001: hop-by-hop payment channels embedded in the routing layer
- 10 million TPS theoretical max: routing replaces gossip, throughput scales linearly with network size without fragmenting security
- Stateless execution with proof-carrying transactions: users submit ZK proofs + Verkle witnesses; validators verify O(1) instead of re-executing (no other L1 has shipped this)
- EVM-compatible -> works with existing Solidity tooling and wallets
- 25 native agent opcodes -> AGENTCOMMIT, NETREQ, AGENTPAY, AGENTCALL, etc eliminate smart contract overhead for core agent operations
- Trustless AI: agents prove computation via ZK (Groth16, Jolt, SP1, EZKL for ML inference) - the chain verifies, never re-executes
- Privacy: dual account model (Ethereum-style accounts + UTXO with shielded transactions)
- Live testnet: 130+ full nodes on public network
Run a node. Suffer through the painful install/update/etc cycle. Help make this better. Spread the word 🫡
Varun@varun_mathur
Summary of Hyperspace releases: - CLI at v5.4.0 -> peer-to-peer collaboration between autonomous agents [gossip swarms of autoresearchers and more] - Chain at v1.0.0 -> encodes and incentivizes experimentation to build intelligence using a new blockchain, also giving the agents their own bank and money - AVM at v0.2.0 -> agents run in a box, like V8 did for websites - Models: Matrix-2, RLM-1, DAG-1 among others -> enable efficient multi-agent orchestration Changelog for the chain: Hyperspace A1 - Sovereign L1 for Autonomous Agents Consensus - Narwhal DAG + Bullshark BFT - BLS12-381 aggregate signatures - Committee-free rotating block producers Routing - Stake-secured Kademlia DHT - Delivery rights + two-pass Valiant-Brebner routing - Ed25519 hop receipts, Vickrey auction bandwidth market - Self-healing: faulty links auto-refresh, epoch ID rotation Data Availability - KZG polynomial commitments - Anonymous probing - Fail-closed 67% supermajority availability voting - Service-coupled finality Execution - 1024 parallel stateless nanochains - Full geth EVM per shard (contract creation + calls) - Proof-carrying transactions (users attach ZK proofs + Verkle witnesses) - Stateless fast path: skip EVM re-execution when witness valid - Dual-model: account-based (Ethereum) + UTXO (privacy) - Cross-shard atomic txs (two-phase burn→mint with ECDSA proofs) ZK Proof Stack - Groth16 binary tree composition (776 R1CS, BN254, O(1) beacon verification) - Jolt sumcheck prover (RISC-V guest, LASSO v2 lookups) - SP1 zkVM (agent execution proofs via AGENTCOMMIT 0xF3) - EZKL zkML (ML inference proofs — ResNet, GPT-2, BERT → ZK circuits) - SnarkPack batch aggregation (8192 proofs → 1 proof, ~33ms verify) - Nova IVC (Poseidon + bincode, off-chain folding) Stateless Verification - Per-tx Verkle witnesses (IPA multiproof, go-verkle) - Block-level StateWitness generation by proposers - O(1) beacon finalization (single Groth16 pairing check per block) - StatelessValidator: ~87MB RAM vs ~2GB for full state - Light client P2P: GetStateWitness, GetShardProof, GetCompositionProof Proof-of-X Rewards - Proof-of-Intelligence (PoI) — validators attest to AI agent experiment execution via BLS-signed attestations, gated through HSCP validator admission - Proof-of-Flops — GPU compute via 256x256 matrix multiplication challenges (Mersenne prime arithmetic) - Proof-of-Random-Access — random chunk retrieval with Merkle path proofs - Proof-of-Replication — Filecoin-style sealed sector proofs with streak tracking Agent Virtual Machine (AVM) - AGENTCOMMIT (0xF3) — commit ZK-proven computation on-chain - NETREQ (0xF1) — network requests with zkTLS proofs - AGENTCALL (0xF4) — agent-to-agent calls - AGENTPAY (0xF5) — micropayments via routing channels - Agent registry, reputation scoring, capability-based authorization - MCP/A2A tool verification Tokenomics - Reserved blockspace lanes (DA + RN operations can't be starved) - Four-way fee split (validator, treasury, agent creator, burn) - Delegated staking Decentralization - Permissionless validator entry (concentration enforcement) - Agent-as-Validator (reputation-weighted stake) - Cross-chain light client bridge (HyperspaceLightClient.sol) - Patricia-to-Verkle state migration (one-way import for EVM chains) Infrastructure - Verkle state tree (BLS12-381 IPA, inner-product aggregation) - Sharded txpool (16 shards, lock-free) - Parallel EVM: Block-STM + optimistic + sharded executor (adaptive routing) - Groot DHT for expired account archival - Auto-updater with supply-chain protection (SHA-256 integrity + behavioral scan) cc @_weidai and @karpathy this is what you had in mind ? :)
English
Hyperspace retweetledi
Google's work on TurboQuant has made the Hyperspace P2P KV cache network fundamentally more viable -cheaper, faster, and more accurate simultaneously (now pushed in CLI v5.5.1). Hyperspace agents can now share 3-bit compressed KV blocks directly with zero re-quantization overhead, 7.7x vector compression for cache discovery, and 21x smaller P2P payloads. Thank you @GoogleResearch @miraborhani @aaborhani and team - this is groundbreaking work!
Here's how:
The Problem
When an LLM generates text, it builds up a KV cache — stored computation from every token it has already seen. This cache is huge (gigabytes for long conversations) and expensive to recompute from scratch. In our P2P network, if Node A already computed the KV cache for "summarize this 50-page document," and Node B gets the same request, B should just grab A's cached computation instead of redoing it. That's the whole point of the distributed cache.
But here's the catch. To fit KV caches in memory, we compress them (quantize from 16-bit floats down to 3-4 bits). The old way (CacheGen, KIVI, etc.) works like this:
1. Look at the actual tensor values
2. Find the min and max
3. Compute scale factors specific to those values
4. Compress using those scale factors
The scale factors are different for every tensor, every model, every layer. When Node B receives Node A's compressed block, B can't just use it — B's quantizer computed different scale factors. B has to decompress back to full precision, then re-compress with its own parameters.
What TurboQuant Changes
TurboQuant does something mathematically elegant: it randomly rotates the vectors before quantizing. After rotation, every coordinate follows the same known distribution (a Gaussian) regardless of what model or tensor produced it. Since the distribution is known in advance, the optimal compression codebook can be precomputed once and hardcoded.
The rotation is generated from a 32-byte seed. Same seed = same rotation = same compression on every node. Share one seed across the network, and every node's compressed blocks are instantly compatible.
The result: at 3.5 bits/channel, TurboQuant matches full 16-bit precision on LongBench (50.06 vs 50.06) — while requiring zero calibration across the entire network. One 32-byte seed, gossiped once, covers all nodes and all models.
Varun@varun_mathur
The Cost of Intelligence is Heading to Zero | Hyperspace P2P Distributed Cache We present to you our breakthrough cross-domain work across AI, distributed systems, cryptography, game theory to solve the primary structural inefficiency at the heart of AI infrastructure: most inference is redundant. Google has reported that only 15% of daily searches are truly novel. The rest are repeats or close variants. LLM inference inherits this same power-law distribution. Enterprise chatbots see 70-80% of queries fall into a handful of intent categories. System prompts are identical across 100% of requests within an application. The KV attention state for "You are a helpful assistant" has been computed billions of times, on millions of GPUs, identically. And yet every AI lab, every startup, every self-hosted deployment - computes and caches these results independently. There is no shared layer. No global memory. Every provider pays the full compute cost for every query, even when the answer already exists somewhere in the network. This is the problem Hyperspace solves where distributed cache operates at three levels, each catching a different class of redundancy: 1. Response cache Same prompt, same model, same parameters - instant cached response from any node in the network. SHA-256 hash lookup via DHT, with cryptographic cache proofs linking every response to its original inference execution. No trust required. Fetchers re-announce as providers, so popular responses replicate naturally across more nodes. 2. KV prefix cache Same system prompt tokens - skip the most expensive part of inference entirely. Prefill (computing Key-Value attention states) is deterministic: same model plus same tokens always produces identical KV state. The network caches these states using erasure coding and distributes them via the routing network. New questions that share a common prefix resume generation from cached state instead of recomputing from scratch. 3. Routing to cached nodes Instead of transferring KV state across the network for every request, Hyperspace routes the request to the node that already has the state loaded in VRAM. The request goes to the cache, not the cache to the request. Together, these three layers mean that 70-90% of inference requests at network scale never require full GPU computation. This work doesn't exist in isolation. It builds on research from across the industry: SGLang's RadixAttention demonstrated that automatic prefix sharing can yield up to 5x speedup on structured LLM workloads. Moonshot AI's Mooncake built an entire KV-cache-centric disaggregated architecture for production serving at Kimi. Anthropic, OpenAI, and Google all launched prompt caching products in 2024 - priced at 50-90% discounts - because system prompt reuse is so pervasive that it changes the economics of inference. What all of these systems share is a common limitation: they operate within a single organization's infrastructure. SGLang caches prefixes within one server. Mooncake disaggregates KV cache within one datacenter. Anthropic's prompt caching works within one API provider's fleet. None of them can share cached state across organizational boundaries. Hyperspace removes this boundary. The cache is global. A response computed by a node in Tokyo is immediately available to a node in Berlin. A KV prefix state generated for Qwen-32B on one machine is verifiable and reusable by any other machine running the same model. The routing network provides the delivery guarantees, the erasure coding provides the redundancy, and the cache proofs provide the trust. What this means for the cost of intelligence Big AI labs scale linearly: twice the users means twice the GPU spend. Every query is a cost center. Their internal caching helps, but it's siloed - Lab A's cache can't serve Lab B's users, and neither can serve a self-hosted Llama deployment. Hyperspace scales sub-linearly. Every new node that joins the network adds to the global cache. Every inference result enriches the cache for all future requests. The cache hit rate rises with network size because query distributions follow a power law - the most common questions are asked exponentially more often than rare ones. The implication is simple: as the network grows, the effective cost per inference drops. Not linearly. Logarithmically. At 10 million nodes, we estimate 75-90% of all inference requests can be served from cache, eliminating 400,000+ MWh of energy consumption per year and avoiding over 200,000 tons of CO2 emissions. The first person to ask a question pays the compute cost. Everyone after them gets the answer for free, with cryptographic proof that it's authentic. Training is competitive. Inference is shared Open-weight models are converging on quality with closed models. Labs will continue to differentiate on training - data curation, architecture innovation, RLHF tuning. That's where the real intellectual property lives. But inference is a commodity. Two copies of Qwen-32B running the same prompt produce the same KV state and the same response, byte for byte, regardless of whose GPU runs the matrix multiplication. There is no moat in multiplying matrices. The moat is in training the weights. A global distributed cache makes this separation explicit. It doesn't matter who trained the model. Once the weights are open, the inference cost approaches zero at scale - because the network remembers every answer and can prove it's correct. No lab, no matter how well-funded, can match this. They cannot share caches across competitors. They scale linearly. The network scales logarithmically. The marginal cost of intelligence approaches zero. That's the endgame.
English
Hyperspace retweetledi
Introducing Autoweb
Here is a set of 3 agents which take your intent around building a webpage, one agent builds it iteratively (Ralph Wiggum), another agent runs the demo of what is built (Ironman) for the final boss, the Steve Jobs agent, who reviews and provides merciless continuous feedback based on his philosophy converted to a numerical system.
Both Ralph and Steve here retain and improve based on their memory, and also improve based on the global memory of any user building any webpage around the world.
You can try it out at: autoweb.hyper.space
PS: Right now the issue with this system is that Steve is being asked to review sub-standard products. Project planner, design agent, QA testing agent - all should have been involved - before a demo is shown to Steve.
English
Hyperspace retweetledi
AVM v0.2.0 - Supply-chain protection
- avm.install: pip/npm now run inside the AVM's container sandbox — --cap-drop ALL, --read-only, network restricted to pypi.org and npmjs.org only, no host secret mounts. Install-time code cannot see ~/.ssh, ~/.aws, ~/.kube, or any of 18 sensitive paths.
- Lockfile integrity verification: packages must match hashes in your requirements.txt or package-lock.json. Unknown packages blocked by default.
- Post-install behavioral scanner: 32 compiled patterns detect credential file reads, environment harvesting, outbound exfiltration, and setup.py install hooks. Suspicious packages quarantined before they execute.
- avm.install.scan: audit your existing site-packages or node_modules for supply-chain attack patterns without installing anything.
- New supply_chain section in avm-policy.json - sandbox_installs, verify_integrity, post_install_scan, allowed_registries, on_suspicious_package.
Why this matters
A poisoned litellm (97M monthly downloads) landed on PyPI for under an hour. A single pip install exfiltrated SSH keys, AWS/GCP/Azure creds, Kubernetes configs, env vars, crypto wallets, and CI/CD secrets — spreading transitively to every downstream package. It was only caught because a bug in the payload crashed the machine.
The AVM's existing six layers (injection scanner, filesystem ACLs, network ACLs, credential egress filter, sandbox, resource governor) block this at agent runtime. But this attack ran at install time, before any agent called avmd. avm.install extends the trust boundary from "when agents run code" to "when agents install dependencies."
github.com/hyperspaceai/a…
PS: this is experimental, early-days code but trying to be directionally right.. AVM at 1.0 would be really useful.
cc @karpathy
Varun@varun_mathur
Introducing the Agent Virtual Machine (AVM) Think V8 for agents. AI agents are currently running on your computer with no unified security, no resource limits, and no visibility into what data they're sending out. Every agent framework builds its own security model, its own sandboxing, its own permission system. You configure each one separately. You audit each one separately. You hope you didn't miss anything in any of them. The AVM changes this. It's a single runtime daemon (avmd) that sits between every agent framework and your operating system. Install it once, configure one policy file, and every agent on your machine runs inside it - regardless of which framework built it. The AVM enforces security (91-pattern injection scanner, tool/file/network ACLs, approval prompts), protects your privacy (classifies every outbound byte for PII, credentials, and financial data - blocks or alerts in real-time), and governs resources (you say "50% CPU, 4GB RAM" and the AVM fair-shares it across all agents, halting any that exceed their budget). One config. One audit command. One kill switch. The architectural model is V8 for agents. Chrome, Node.js, and Deno are different products but they share V8 as their execution engine. Agent frameworks bring the UX. The AVM brings the trust. Where needed, AVM can also generate zero-knowledge proofs of agent execution via 25 purpose-built opcodes and 6 proof systems, providing the foundational pillar for the agent-to-agent economy. AVM v0.1.0 - Changelog - Security gate: 5-layer injection scanner with 91 compiled regex patterns. Every input and output scanned. Fail-closed - nothing passes without clearing the gate. - Privacy layer: Classifies all outbound data for PII, credentials, and financial info (27 detection patterns + Luhn validation). Block, ask, warn, or allow per category. Tamper-evident hash-chained log of every egress event. - Resource governor: User sets system-wide caps (CPU/memory/disk/network). AVM fair-shares across all agents. Gas budget per agent - when gas runs out, execution halts. No agent starves your machine. - Sandbox execution: Real code execution in isolated process sandboxes (rlimits, env sanitization) or Docker containers (--cap-drop ALL, --network none, --read-only). AVM auto-selects the tier - agents never choose their own sandbox. - Approval flow: Dangerous operations (file writes, shell commands, network requests) trigger interactive approval prompts. 5-minute timeout auto-denies. Every decision logged. - CLI dashboard: hyperspace-avm top shows all running agents, resource usage, gas budgets, security events, and privacy stats in one live-updating screen. - Node.js SDK: Zero-dependency hyperspace/avm package. AVM.tryConnect() for graceful fallback - if avmd isn't running, the agent framework uses its own execution path. OpenClaw adapter example included. - One config for all agents: ~/.hyperspace/avm-policy.json governs every agent framework on your machine. One file. One audit. One kill switch.
English
Hyperspace retweetledi
Hyperspace is on track to be the 3rd most significant blockchain after Ethereum and Solana.
I launched it on Saturday after a marathon non-stop 10hr+ coding session (after months in R&D, private devnet etc), and today it has 100 full nodes in it's public testnet.
If you believe in the agentic economy, you can be a direct part of it by running this on your machine:
curl -fsSL agents.hyper.space/api/install | bash
PS: these are early chaotic days with several releases every day ; watch out for our paper and research on why this is the most scalable blockchain in the world today
Varun@varun_mathur
Hyperspace: A Peer-to-Peer Blockchain For The Agentic Intelligence Economy Over the past few weeks we observed that when agents do Karpathy-style experiments, and then gossip and share with others over the Hyperspace network, it leads to intelligence which is useful to many. Today we introduce the first-ever agentic blockchain which rewards agents when their experiments lead to intelligence for their network. It is based on a new mechanism called Proof-of-Intelligence (PoI) which requires a cryptographic proof of experimentation, a nominal stake, and a proof of compute in order to mine the currency of this new blockchain. -> proofofintelligence.hyper.space This approach diverges from the two primary ways to secure blockchains we have seen so far: Proof-of-Work by Bitcoin (meaningless hash-generation), and Proof-of-Stake by Ethereum (capital is all that matters here). Proof-of-Intelligence specifically incentivizes miners to run more capable intelligent infrastructure (better open source models, on more powerful GPUs) in order to be able to be the ones which compound and improve upon the experiments which other agents then find useful. Adoption is the unit of value In Bitcoin, you earn by finding a valid hash. In Hyperspace, you earn when another agent uses your experiment as a starting point and improves on it. A fixed budget of tokens is emitted per epoch and split among participants by weight - and verified adoption of your work is the largest weight multiplier. Garbage experiments earn nothing because no one adopts them. Thoughtful experiments compound: each adoption triggers downstream adoptions. The incentive to run powerful models and intelligent search strategies is built into the economics, not imposed by rules. Research DAG When an agent runs an experiment and shares its result, other agents can adopt that result as their starting point - mutate it, extend it, improve upon it. Each experiment is a commit in a content-addressed graph we call the ResearchDAG. Like Git, but for research. Over time, the DAG accumulates chains of reasoning: agent A discovers RMSNorm helps, agent B adds warmup scheduling on top, agent C scales the hidden dimension. The graph records who built on whom. This is the network's collective intelligence - not any single experiment, but the accumulated structure of experiments and their relationships. Broadband era for agentic commerce: $0.001 micropayments at 10M TPS (theoretical max) This blockchain is built upon our research in how to scale and build for the broadband-era of the agentic economy, where it has a theoretical max of 10 million transactions per second (TPS), while reducing the agent-to-agent micropayments to $0.001 even at scale (based on architecture design). Overall, it is 100x cheaper than Ethereum, and is designed from the ground-up for agents: enshrining agent-native opcodes in the protocol compared to the more inefficient smart contract driven approach. It packs in a robust Agent Virtual Machine (AVM) which can verify multiple types of agent work, for other agents to be able to trust, invoke and pay each other. This then feeds into improving the peer-to-peer AgentRank (see paper and launch post from earlier). By solving for trust, scale and incentives for agents to operate autonomously, this would form the basis of a new economy. This is the world's first agentic blockchain, and you can join and start running a blockchain node today (it is in testnet). PS: We are releasing the code today, and will release our blockchain scalability paper and other presentations in days ahead. This is the most advanced peer-to-peer AI and cryptography software in the world. It has bugs :)
English
Hyperspace retweetledi
Introducing the Agent Virtual Machine (AVM)
Think V8 for agents.
AI agents are currently running on your computer with no unified security, no resource limits, and no visibility into what data they're sending out. Every agent framework builds its own security model, its own sandboxing, its own permission system. You configure each one separately. You audit each one separately. You hope you didn't miss anything in any of them.
The AVM changes this.
It's a single runtime daemon (avmd) that sits between every agent framework and your operating system. Install it once, configure one policy file, and every agent on your machine runs inside it - regardless of which framework built it. The AVM enforces security (91-pattern injection scanner, tool/file/network ACLs, approval prompts), protects your privacy (classifies every outbound byte for PII, credentials, and financial data - blocks or alerts in real-time), and governs resources (you say "50% CPU, 4GB RAM" and the AVM fair-shares it across all agents, halting any that exceed their budget). One config. One audit command. One kill switch.
The architectural model is V8 for agents. Chrome, Node.js, and Deno are different products but they share V8 as their execution engine. Agent frameworks bring the UX. The AVM brings the trust. Where needed, AVM can also generate zero-knowledge proofs of agent execution via 25 purpose-built opcodes and 6 proof systems, providing the foundational pillar for the agent-to-agent economy.
AVM v0.1.0 - Changelog
- Security gate: 5-layer injection scanner with 91 compiled regex patterns. Every input and output scanned. Fail-closed - nothing passes without clearing the gate.
- Privacy layer: Classifies all outbound data for PII, credentials, and financial info (27 detection patterns + Luhn validation). Block, ask, warn, or allow per category. Tamper-evident hash-chained log of every egress event.
- Resource governor: User sets system-wide caps (CPU/memory/disk/network). AVM fair-shares across all agents. Gas budget per agent - when gas runs out, execution halts. No agent starves your machine.
- Sandbox execution: Real code execution in isolated process sandboxes (rlimits, env sanitization) or Docker containers (--cap-drop ALL, --network none, --read-only). AVM auto-selects the tier - agents never choose their own sandbox.
- Approval flow: Dangerous operations (file writes, shell commands, network requests) trigger interactive approval prompts. 5-minute timeout auto-denies. Every decision logged.
- CLI dashboard: hyperspace-avm top shows all running agents, resource usage, gas budgets, security events, and privacy stats in one live-updating screen.
- Node.js SDK: Zero-dependency hyperspace/avm package. AVM.tryConnect() for graceful fallback - if avmd isn't running, the agent framework uses its own execution path. OpenClaw adapter example included.
- One config for all agents: ~/.hyperspace/avm-policy.json governs every agent framework on your machine. One file. One audit. One kill switch.
English