Jeremy Koch (@ItsFloe), Market Intelligence at NEAR
Key Insights
- The industry has shifted from vision to execution. Across scaling, accounts, execution, and interoperability, the meaningful question is no longer which chain has the boldest design, but which has moved functionality from roadmap to mainnet.
- Early account-model choices now bound each chain's flexibility. NEAR's programmable, human-readable accounts make features like scoped delegation and post-quantum key rotation native, while Ethereum retrofits similar capability through account abstraction and Solana's leaner model favors parallel-execution speed over identity ergonomics.
- Each chain has a clear, defensible center of gravity. Ethereum provides the neutral base layer institutions build on, Solana the speed retail traders want, Zcash embodies the privacy cypherpunks values, and NEAR is the connective rails between them.
- The roadmaps are converging on similar capabilities from different starting points. Sub-second finality, parallel execution, statelessness, and post-quantum security appear across all four forward plans, a sign the industry broadly agrees on where infrastructure needs to go, even as timelines and approaches differ.
Executive Summary
The blockchain industry has entered a phase where architectural promises are finally meeting real-world production constraints. After years of whitepapers, testnets, and hard-fought upgrades, the question is no longer which chain has the boldest vision but which chain has actually shipped the most functionality to mainnet.
I took a deep look at four of the most advanced and unique protocols, NEAR Protocol, Ethereum, Solana, and Zcash, across six main dimensions:
- Scaling Architecture & Security Model
- Account Model
- Execution Environment
- Cross-chain Interoperability
- Roadmap
- Art of the Possible
My thesis is simple: The current state of NEAR mainnet already has the functionality and extensibility that the majority of other chains are still designing as long dated roadmap targets.
Key functionality live on NEAR includes dynamic sharding, stateless validation, post-quantum signatures, and native chain abstraction. This is not an argument that there will be one winner. I believe in a multi-chain future where each ecosystem has distinct strengths. This is more of an observation that the gap between roadmap and production is widest where it matters most for the agent economy.
Scaling Architecture
Scaling architecture sets the ceiling on how many users, agents, and transactions a network can serve before performance degrades, and whether it reaches that ceiling by centralizing (raising validator hardware requirements) or by decentralizing (adding shards, removing state from validation). The distinction compounds over time, a chain that scales horizontally and statelessly can grow capacity without pricing out its validators, which is the precondition for the consumer and agent-scale volume where millions of autonomous actors transact continuously. Get this wrong and every application built on top inherits a hard limit. Get it right and the base layer stops being the bottleneck.
NEARNEAR's scaling story is unique in the industry because it was designed around sharding from day one, not retrofitted.
Nightshade 2.0
One of NEAR’s most important upgrades since launch was Nightshade 2.0 in late 2024. At its core is stateless validation (NEP-509): validators no longer store the full state of the shards they secure. Each block instead carries a compact state witness (a proof of only the relevant state slice), so any validator can verify a chunk without keeping the entire trie locally. This is the key architectural advance. By decoupling validation from state storage, NEAR can add shards to increase capacity without forcing validators to run progressively-heavier hardware, the exact pressure that drives most high-throughput chains toward centralization. One supporting change completes the upgrade: per-shard congestion control creates isolated fee markets, so an overloaded shard (e.g., a popular mint) raises fees only locally instead of slowing the whole network. Post-activation, NEAR has been able to sustain ~4,000 TPS on real hardware; and when tested during a controlled 70-shardbenchmark the network reached 1 million TPS.
Nightshade 3.0 is already in progress and centers on SPICE (Separation of Consensus and Execution). Today ordering and execution are entangled; SPICE splits them so the network can agree on block order independently of processing the transactions inside. That single change unlocks three capabilities at once: (1) Speed, target block times drop from ~600ms to ~200ms, with finality approaching 400ms down from ~1.2s, (2) Atomicity, true cross-shard, multi-contract atomic execution becomes possible (a transaction spanning several shards succeeds or fails as one unit), (3) Base-layer privacy, a private shard for confidential transactions that run directly at the protocol level (no MEV or frontrunning, while still allowing verifiable settlement and selective disclosure).
Together the two versions form a clear trajectory: Nightshade 2.0 let NEAR scale horizontally without centralizing; 3.0 aims to make a sharded chain feel like a single, fast, private state machine by removing the usual cross-shard friction and latency.
Dynamic Resharding
Sharding only works if the network can add shards when demand requires it. Until 2026 that remained the weak link: the split itself was already fast (executed inside a single block with no user interruption), but scheduling it was slow. Because resharding rode on a protocol upgrade, each increase required validator coordination and a working-group vote. NEAR has grown from 1 shard at launch to 9 today (plus a private shard for Confidential Intents) only through that manual, one-upgrade-at-a-time process.
Dynamic resharding, shipped in the v2.13 upgrade, removes the human bottleneck. When a shard crosses a state-size threshold the network splits it automatically at the next epoch boundary, deterministically, validated by the same state witnesses that power Nightshade 2.0’s stateless validation, and typically within ~1.5 epochs (a matter of hours). No upgrade, no vote. Capacity now tracks demand in real time; neither storage nor throughput remains a scaling ceiling. This is Phase 2 of NEAR’s sharding vision, reinforced by a companion feature most chains lack: sharded smart contracts (NEP-616, late 2025). A single application’s state can now span multiple shards instead of being locked to one, even enabling a sharded fungible token. Because NEAR’s account model already treats every user as effectively its own contract, an app or user base can expand horizontally across shards as it grows.
Together, automatic resharding and sharded contracts means an application facing a demand spike, or an agent workload generating millions of transactions, simply scales with the load. NEAR is no longer merely sharded, it reshards itself. That is exactly what a settlement layer for millions of autonomous agents requires.
Post-Quantum Signatures
The quantum threat to blockchains is straight-forward: a sufficiently powerful quantum computer could derive private keys from the public keys that secure them, and essentially no production chain today runs quantum-resistant cryptography. NEAR's answer is the payoff of an old design decision. Because a NEAR account is decoupled from its cryptography, it is a human-readable name controlled by rotatable access keys, not an address bound to a single keypair, adding a new signature scheme is a routine extension rather than a chain-wide migration. NEAR already supported two schemes (Ed25519 by default, secp256k1); v2.13 upgrade added FIPS-204 / ML-DSA-65, a lattice-based, NIST-approved post-quantum scheme, the third, usable for both access keys and transaction signing and exposed directly in the NEAR CLI. Any holder can become quantum-safe by running a single transaction to rotate their keys. NEAR is one of the first major L1s to bring NIST-approved post-quantum signing to mainnet, and the early team's decision years ago to build human-readable accounts with future quantum safety in mind, is precisely what made that possible on this fast of a timeline.
This is only the first step toward a quantum-resistant ecosystem. Much more work remains across wallets, hardware devices, validator infrastructure, and the broader crypto stack before the industry can withstand a sufficient quantum computer. No single upgrade is enough. That is why NEAR is exploring multiple paths to help not only its own ecosystem, but the broader crypto industry transition to a quantum-resistant future, from infrastructure upgrades to cross-chain security and new approaches to asset recovery.
Validator Requirements & Security Model
NEAR is secured by a seat-based proof-of-stake model whose two-tier design is deliberately engineered for both performance and decentralization. NEAR'svalidator set is split into two tiers: (1) heavier block-and-chunk producers, and (2) a lighter chunk-validation role. The top 100 validators by stake act as block and chunk producers, each assigned to a shard, and running the heavier hardware profile (eight or more cores, ~48 GB RAM, 2-3 TB NVMe). Validators below the top 100 serve as chunk validators, a lighter role that does not track shards and runs on modest machines (eight cores, 8-16 GB RAM, a 1-2 TB SSD), which is what lets the active set expand beyond the core producers. There is no fixed minimum stake. Eligibility is set each epoch by auction, pegged to the 300th-largest staking proposal and floored at 25,500 NEAR (~$45,900 at $1.80/ NEAR), with the live seat price published in real time on NearBlocks.
Ethereum
Ethereum's scaling story since 2024 has been the disciplined execution of a single thesis: the base layer should not try to be a high-throughput chain, but should instead make data cheap for the Layer 2 rollups that carry execution.
Three upgrades built that out. Dencun (March 2024) introduced proto-danksharding via EIP-4844, giving rollups a dedicated "blob" space to post data and cutting L2 transaction costs by roughly 90% almost overnight. Pectra (May 2025) raised the per-block blob target from three to six (nine maximum), shipped a batch of staking quality-of-life changes including a higher maximum effective validator balance, and activated EIP-7702, letting externally owned accounts temporarily delegate to contract code, Ethereum's first real step toward native account abstraction. Fusaka (December 2025) then shipped PeerDAS, which lets validators sample blob data rather than download all of it, delivering roughly an order-of-magnitude increase in the data-availability capacity available to L2s.
The result, by mid-2026, is a base layer that is modest by intent, on the order of 100-150 transactions per second at its theoretical ceiling, and less than that sustained with real throughput living across dozens of rollups. In Ethereum's design this is a feature rather than a limitation. The L1 optimizes for security, neutrality, and data availability while execution scales offchain. The trade-off it accepts, and what the Glamsterdam roadmap is meant to begin fix, is fragmentation. Liquidity and users are spread across many L2s, basically duplicating the silo issue that has been present in the space forever. It seems Ethereum is betting on modular, offchain execution, precisely where NEAR is betting on scaling the base layer itself.
Validator Requirements & Security Model
Ethereum is secured by pure proof-of-stake. Economic security comes from the large volume of staked ETH and the high capital cost of acquiring a controlling share. Serious misbehavior (double-signing, surround voting, etc.) triggers slashing: an initial penalty plus a correlation penalty that can escalate significantly if many validators offend at the same time. Simple offline periods only produce inactivity penalties / missed rewards rather than full stake loss.
Becoming an Ethereum validator requires staking 32 ETH, about $59,000 at ~$1,830/ ETH, though Pectra's higher effective-balance ceiling (up to 2,048 ETH per validator) now lets large operators consolidate many validators into one. Hardware requirements have risen rather than fallen. After Fusaka activated PeerDAS in December 2025, the data-availability sampling it introduced pushed recommended specs to roughly 8-16 CPU cores, 64 GB of RAM (32 GB minimum), a 4 TB NVMe SSD, and a sustained ~100 Mbps connection. That is the mirror image of NEAR's trajectory, where stateless validation lowered NEAR's hardware floor, PeerDAS raised Ethereum's, a reminder that scaling data availability at the base layer carries real node-cost consequences. On participation, roughly 900,000 active validators secure the network as of mid-2026, down from a peak near one million as consolidation took hold, collectively staking about 40.7 million ETH (~34% of supply). That validator count is by far the largest of any chain in this comparison, but an increasing share sits with large staking providers and institutions, so the raw number overstates the degree of genuinely independent operation.
Solana
Solana takes the opposite bet to NEAR. Rather than sharding, it is a single monolithic chain that scales vertically, one global state machine whose Sealevel runtime executes non-overlapping transactions in parallel across a validator's cores. The design maximizes raw single-chain performance and composability, at the cost of high validator hardware requirements.
In production, Solana processes on the order of a few thousand to ~10,000 transactions per second, well below its theoretical ceiling because block compute limits and validator hardware, not the protocol's ambition, are the binding constraint. That ceiling is rising: on July 29, 2026, SIMD-0286 raised the per-block compute limit 66%, from 60M to 100M compute units, a change made feasible only because more than 70% of stake had adopted XDP kernel-bypass networking. Client diversity is the other headline of the 2025/26 cycle. Agave (Anza's Rust client) remains dominant, but Firedancer, Jump Crypto's independent C/C++ client, reached mainnet in December 2025, and as of early August 2026, Firedancer accounts for roughly 13-14% of staked SOL (across ~55 validators out of ~700 active ones). Separately, ZK Compression is live but nascent, storing account hashes in Merkle trees with off-chain data and ZK validity proofs to enable rent-free tokens and PDAs.
Alpenglow (not yet live)
The largest change is still ahead. Alpenglow, the most significant consensus overhaul in Solana's history, was on testnet as of mid-2026 and arrives in two parts: Votor replaces Tower BFT with a simpler protocol targeting ~150-ms finality, dramatic cut from today's ~400 ms pre-confirmation latency and ~12.8-second Tower BFT finality, while Rotor replaces the Turbine block-propagation layer. Mainnet activation is expected in Q3-Q4 2026, though the timeline remains fluid. If it lands, Alpenglow would give Solana finality in the same sub-second range NEAR has run in production since 2024, closing one of the clearest gaps in this comparison. Firedancer, for its part, is operational but has not reached its full potential; the 1 million+ TPS it is designed for remains aspirational in production.
Validator Requirements & Security Model
Solana is secured by proof-of-stake on a single monolithic chain. Economic security comes from the total staked SOL and the capital required to control a meaningful share of the validator set. Formalized onchain slashing for certain faults remains limited or still in the proposal stage, so much of the security still relies on economic incentives and operator reputation rather than automatic stake destruction.
Solana sits at the high-hardware, high-cost end of this comparison. There is no protocol-level minimum stake, technically anyone can run a validator with any amount of SOL, but the economics impose a steep practical floor. Validators pay ongoing vote fees (historically ~1.1 SOL per day), so a sustainable validator needs substantial delegated stake, with break-even commonly cited in the tens of thousands of SOL. At SOL's ~$73 price in August 2026, a ~20,000 SOL position is roughly $1.5 million. The hardware bar is correspondingly steep: on the order of 16+ CPU cores, 256+ GB of RAM, NVMe SSDs, and a 10 Gbps connection. And the trend runs against decentralization, the active set has fallen to roughly 700 validators, down from a peak above 2,500, as thin economics squeeze smaller operators. Solana gains its throughput with concentration, the mirror image of NEAR's low-hardware, expand-the-set design.
Zcash
Zcash occupies a distinct niche in this comparison. It is a privacy-focused, UTXO-based chain descended from Bitcoin's codebase, with zero-knowledge proofs at its core and, by design, little in the way of general smart-contract capability. Where the other three networks are general-purpose platforms, Zcash is purpose-built for one thing: private money.
Zcash is fresh off a significant and somewhat painful upgrade. NU6.3 (Ironwood), which went live on July 28, 2026, sealing the existing Orchard shielded pool, which held roughly 3.66 million ZEC, about $1.7 billion, after developers found a soundness bug in the Orchard proof circuit that had gone undetected for years, and opened a fresh private pool from zero to restore verifiable supply integrity. It was a necessary security reset that consumed considerable engineering effort. Throughput remains modest by design: on the order of ~2.9 TPS for Orchard shielded transactions up to ~10 TPS for the older Sapling pool, with a 75-second block time. On the client side, Zebra, the Zcash Foundation's Rust implementation, is now the primary node software, the legacy zcashd (a Bitcoin C++ fork) having reached end of life on July 18, 2026.
NU7 (under development, testnet live)
NU7, with a testnet (NU7-rc0) live, bundles several changes: block times cut from 75 to 25 seconds (3× faster), Zcash Shielded Assets (ZSAs) to extend private issuance and transfer to arbitrary tokens rather than just ZEC, quantum recoverability designed to let users recover funds if the underlying cryptography breaks, and proposals for explicit fees and fee burning. Its centerpiece is Project Tachyon, which enjoys broad community support and re-architects how wallets and nodes handle shielded state, proof-carrying wallets, oblivious sync, targeting Visa/Mastercard-scale protected throughput (a 50,000 TPS goal, which is much lower than any other chain we have looked at). If realized, Tachyon would make shielded transactions performant enough for mainstream payments, historically the biggest practical limit on Zcash's privacy.
Beyond NU7, NU8 and later upgrades would deepen the Tachyon architecture, always under the constraint that shielded transactions require computationally expensive ZK proofs, the tax Zcash pays for cryptographic privacy. There are no smart contracts in the general sense; the scope is, and is meant to be, private payments. A move to proof-of-stake finality, the Crosslink design from Shielded Labs, which layers PoS finality atop the existing PoW chain, is in active development but not yet committed to mainnet.
Validator / Mining Requirements
Zcash is secured by pure Equihash proof-of-work. There is no stake and no minimum-stake economics; security derives from the real-world cost of acquiring and operating specialized ASIC hardware plus electricity. Since roughly 2020 the network has been dominated by purpose-built Equihash ASICs rather than consumer GPUs, which raises the capital barrier to mining and concentrates hashrate among industrial operators. The proposed Crosslink design would layer a proof-of-stake finality gadget on top of the existing PoW chain, but it remains under development and has not been activated on mainnet. Until then, participation means mining hardware and power rather than capital lock-up, a fundamentally different security and decentralization profile from the three staked chains in this comparison.
Account Model
The account is the atomic unit of identity, ownership, and control, and its design determines everything a user or an agent can natively do. Including key recovery, delegate scoped permissions, gas sponsoring, batch actions, and basic identity. A thin account model (a bare keypair) forces this logic up into wallets and middleware. A rich native one turns the account into a programmable identity. That difference is what lets an agent act on your behalf with narrow, revocable authority instead of demanding all-or-nothing custody of your keys, the safety property the agent economy depends on.
The comparison table reads as a column of checkmarks. The more important story is what those checkmarks cost each network to earn, or whether it can earn them at all. The account is the atomic unit of identity and control, and each chain's early choice about it now bounds how far it can extend.
NEAR
Against all three, NEAR's account model is arguably its most underappreciated architectural advantage, because it was designed from day one with the features the others are still working toward. A NEAR account is a human-readable name rather than a keypair; it can hold a smart contract; it is controlled by multiple, individually scoped access keys that can be rotated, revoked, or granted narrow permissions; and because authorization is decoupled from gas payment at the protocol level, sponsored (gasless) transactions and batching are native rather than middleware. Everything Ethereum is trying to standardize through the 8141/8130/Tempo debate, and everything Solana reaches for through compression, NEAR shipped at its 2020 mainnet launch. This is why the account model recurs throughout this report: it is the foundation the chain-abstraction, agent, and post-quantum stories all build on. An account that can natively delegate scoped authority is exactly what lets an agent act for a user safely; an account decoupled from its cryptography is exactly what makes a post-quantum key swap routine. The advantage isn't a nicer wallet, it's that a decision made in 2020 quietly pre-solved problems its peers are now spending years on.
Crucially, this account-model advantage is not a moat NEAR uses to compete with these chains, it is the foundation that lets NEAR connect them. The same scoped, self-custodied account that makes NEAR's identity layer rich is what allows Chain Signatures to give a single NEAR account native control over assets on Zcash, Ethereum, Solana, and 30+ other networks, and what lets NEAR Intents settle value across them without a bridge. That reframes NEAR's role: not a rival chasing the same users, but connective tissue between ecosystems, a neutral place where an Ethereum user, a Solana asset, and a Zcash balance can meet and transact under one identity, even confidentiality. NEAR's account model isn't a wall around its own ecosystem; it's a doorway into everyone else's. The outcome it's built for isn't other chains losing, but every chain becoming reachable, safely, and on its own terms.
Ethereum
Ethereum shows what it looks like to retrofit a rich account model onto a design that didn't begin with one. Because Ethereum's base unit is the externally owned account, a bare keypair, every capability users now expect (gas sponsorship, batching, session keys, social recovery) has had to be built as an add-on. An example of this is ERC-4337, which built account abstraction entirely outside the protocol via a separate mempool of "UserOperations" processed by bundlers and paymasters; then EIP-7702, shipped in Pectra, adding consensus-level delegation so an EOA can temporarily act as a smart account. Now there's an unresolved standards fight over what native account abstraction should even be. On one side, EIP-8141, the "frame transactions" formalization of EIP-7701, backed by Vitalik Buterin, optimizes for long-term flexibility and post-quantum readiness. On the other side, Coinbase/Base's EIP-8130 and Paradigm's Tempo prioritize shipping something bounded and simple. None has actually shipped. EIP-8141 holds only "Considered for Inclusion" status for the Hegotá fork, with client teams flagging its complexity. The point is not that Ethereum is slow, it will get there, but that account abstraction is genuinely hard to add after the fact, and Ethereum is paying that cost in years and standards debates.
Solana
Solana's account model is robust and fast, but comparatively inflexible. Accounts are identified by base58 public keys with state cleanly separated from programs, excellent for parallel execution, but offering none of the native identity ergonomics (human-readable names, scoped access keys, protocol-level sponsorship) a richer model provides. ZK Compression opens a path to rent-free compressed accounts, but it is a distinct mechanism layered on top, not a property of the base account itself.
Zcash
Zcash sits almost entirely outside this axis. It inherits Bitcoin's UTXO model, shielded and transparent pools of unspent outputs, and simply does not have accounts, programmable keys, or contracts in the sense the others mean. That is not a deficiency so much as a different design for a different purpose: private payments, not programmable identity.
Execution Environment
The runtime and its concurrency model decide which applications are even possible and how cleanly they compose. Sequential versus parallel execution, synchronous versus asynchronous contract calls, and deterministic versus variable gas are not implementation trivia. They determine whether complex, multi-contract, multi-agent workflows run predictably and affordably or collapse under contention and reentrancy risk. As agents begin executing real work across many contracts at once, an execution environment built for safe parallelism becomes the difference between toy applications and dependable automated commerce.
The three runtimes are three genuinely different bets about how a blockchain should execute, and the sharpest place to see the consequences is in how each handles one contract calling another.
NEAR
NEAR's WASM is asynchronous: cross-contract calls are asynchronous and non-blocking. A contract fires a call and finishes its own execution; the result arrives later as a separate callback, by which point the caller's state has already settled. There is no mid-execution handoff to reenter, so the entire reentrancy class largely disappears by construction rather than by developer discipline. The trade-off is real and worth stating plainly: async programming is harder, developers must reason about callbacks and handle a downstream call failing after earlier steps have committed, and cross-contract atomicity is not automatic the way it is on Ethereum. That is precisely the gap the Nightshade 3.0 / SPICE upgrade targets with cross-shard atomic execution, which would restore EVM-like atomic composability without surrendering the safety of the async model.
Ethereum
Ethereum's EVM is synchronous: when a contract calls another, it hands over control and waits, mid-execution, for the result before continuing. That makes composability simple, several contracts can act as one atomic transaction, but it is also the root of reentrancy, the vulnerability class behind Ethereum's history of exploits. Because control passes to an external contract before the caller has finished updating its own state, a malicious callee can call back in and act on stale state. The DAO hack in 2016, roughly $60M at the time, and the event that split the chain into ETH and ETC, was the first, and reentrancy has drained hundreds of millions more since. Developers now defend against it with well-worn patterns (checks-effects-interactions, reentrancy guards), but the risk is inherent to the synchronous model.
Solana
Solana’s Sealevel executes non-overlapping transactions in parallel within its single shard, the source of its throughput, but calls between programs (CPI) remain synchronous and capped at a limited depth. So Solana gets parallelism across independent transactions while inheriting synchronous call semantics within one, bounding composition depth to contain the risk. Zcash, by contrast, has no execution environment to speak of; as a UTXO payments chain it runs no general contracts at all.
This pattern matches each chain's broader philosophy: Ethereum optimizes for composability and accepts a dangerous default; Solana optimizes for parallel throughput and accepts bounded composition; NEAR optimizes for safety and horizontal scale, historically at the cost of easy atomicity, a cost it is now engineering away.
Cross-Chain Interoperability
Value and users are already fragmented across dozens of chains, so how a network connects to the others determines whether it is an island or the connective tissue, and whether connecting is safe or a liability. The historical answer, bridges that lock and wrap assets, produced the single largest category of losses in crypto. An approach that moves authority rather than assets, letting one identity act natively on many chains without a bridge in the path, removes that attack surface and turns interoperability into an extension of user control. In an agent economy that cannot be confined to a single chain, this substrate decides who can transact where.
NEAR
NEAR runs two production systems that, together, make it the connective layer of this comparison. The first is Chain Signatures: using multi-party computation (MPC) threshold signing, a single NEAR account can produce valid signatures for external chains, Ethereum, Solana, Zcash, and 30+ others, turning that account into a smart wallet on every one of them. There is no bridge and no wrapped asset in the path; the account signs once on NEAR, the signature is natively valid on the destination chain, and custody and settlement stay on that chain's own security. It moves authority, not assets. The second is NEAR Intents, a multichain transaction protocol where a user or agent declares a desired outcome, "swap Token A for Token B", and a competitive network of solvers executes it, with a Verifier contract settling atomically. Intents accepts signatures from NEAR, Ethereum, Tron, Solana, Stellar, TON, and passkey wallets, so users arrive from whatever ecosystem they already live in. Chain Signatures supplies the cryptographic reach; Intents supplies the usable settlement layer on top.
Ethereum/Solana/Zcash
The contrast with the other three is stark. Ethereum's interoperability is L2-centric and, by its own admission, fragmented: scaling happens across dozens of rollups, but each L2 carries its own bridge, security model, and liquidity pool, and there is no unified Ethereum account that operates across them natively.The cross-chain intents standard, ERC-7683, introduced by Uniswap and Across, is used in production by UniswapX, and having one of DeFi's largest venues behind it is a meaningful tailwind. But adoption beyond its originators remains thin, and a standard only unifies as far as it is deployed; for now, moving between Ethereum's own L2s can still feel like moving between different chains.
Solana has no native cross-chain interoperability at all. The dominant solution is Wormhole, a third-party bridge, with no protocol-level equivalent of Chain Signatures or Intents, which means cross-chain on Solana still relies on the wrapped-asset bridge model responsible for crypto's largest losses.
Zcash is purposefully isolated, and for sound reasons: its privacy guarantees depend on shielded pools staying self-contained, and the bridges that do connect it are limited and carry deanonymization risk, since linking a shielded asset to another chain can leak exactly what Zcash exists to hide. For Zcash, isolation is a property of its threat model, not a gap in its roadmap. NEAR Intents has become a leading venue for moving in and out of ZEC, more than $1.5 billion in cumulative ZEC volume has settled through it, and Zcash's own flagship wallet, Zashi, taps NEAR Intents for private swaps into fully shielded ZEC. Because Confidential Intents (live since February 2026) executes those swaps inside a TEE-backed private shard, the exchange happens without the client-side proof burden or the deanonymization exposure a conventional bridge would introduce. It is the strongest possible evidence for the connective thesis: even the chain that most wants to stay separate connects through NEAR, and does so while preserving the very privacy that makes bridging anywhere else a liability.
The comparison points one way. Ethereum is still working to connect its own rollups to each other; Solana outsources connection to a third-party bridge; Zcash deliberately stays apart. NEAR is the only one of the four with a production system for connecting all of them, and it does so without asking any of them to give anything up. Chain Signatures does not wrap another chain's assets or route them through a NEAR chokepoint, it lets a user act natively on their chain of choice while each keeps its own security and sovereignty. That is a deliberately cooperative posture: NEAR is not trying to pull liquidity off other chains, it is trying to make them reachable from one place. In an industry that has spent a decade fragmenting, the network that can safely connect the others, without becoming a bridge, a honeypot, or a walled garden, is playing a different game. NEAR's bet is that the connective layer, not any single destination, is where the durable value accrues.
Roadmaps
Reading each network's forward plan reveals its conviction about what the future will demand and, read side by side, shows where the industry is actually converging. It also exposes the gap between shipped and promised, the moments when one chain already runs in production what the others have scheduled for 2027 and beyond. For anyone deciding where durable capability will sit, that comparison is the real signal, because it distinguishes teams that are building toward a future from teams already operating in it.
ETH Compared to NEAR
Seen through that lens, the four roadmaps sort cleanly. Ethereum's 2026-2030 plan: Glamsterdam's parallel execution and proposer-builder separation, Hegotá's move toward statelessness, state expiry, and a still-unchosen native account-abstraction standard, and Strawmap's longer arc toward a faster L1, post-quantum signing, and institutional privacy, is a multi-year effort to reach a set of capabilities NEAR has largely already shipped: parallel sharded execution, stateless validation, native account abstraction, and post-quantum keys are production features on NEAR today, not 2027 targets.
Solana Compared to NEAR
Solana's roadmap is anchored by Alpenglow, its first real shot at sub-second (~150 ms) finality, alongside Firedancer's continued rollout and ZK Compression, a push to reach, on a monolithic chain, the fast deterministic finality NEAR has run since 2024.
Zcash Compared to NEAR
Zcash's NU7 and Project Tachyon aim to scale shielded throughput toward payments scale and add PoS finality (Crosslink) and quantum recoverability, the right ambitions for private money, and precisely the kind of private value transfer NEAR already routes for it through Confidential Intents.
Each ecosystem is building toward a clear future. The difference this comparison keeps surfacing is that, on this specific cluster of capabilities, NEAR is already operating in the one the others are still planning to build.
Art of the Possible
This section moves beyond technical specifications to answer a more strategic question: what can these protocols actually enable in the real world, and what are they already being used for? The answer reveals a clear division of labor, and why NEAR is uniquely positioned as the infrastructure layer for the agent economy.
NEAR: Open Infrastructure for the Agent Economy
Every capability an autonomous agent needs maps to something shown live in an earlier section. Agents need persistent, addressable identities with scoped authority. NEAR's account model supplies human-readable names, rotatable and permission-scoped access keys, and sponsored transactions, so an agent can hold a limited-purpose key while its principal keeps ultimate control and covers its gas. Agents generate orders of magnitude more transactions than humans. NEAR's sharded, stateless architecture already sustains hundreds of thousands of TPS, reshards itself automatically as load arrives, and, with SPICE, is driving finality toward 400ms. NEAR's asynchronous, non-blocking cross-contract calls is the exact execution model that lets many agents fire operations and reconcile results without blocking one another.
Chain Signatures and NEAR Intents let a single account act natively across 35+ chains without a bridge, the difference between an agent confined to one ledger and a cross-chain swarm that monitors and executes on Ethereum, Solana, and Bitcoin from one identity, code on NEAR and actions everywhere. Confidential Intents, private shards, TEE-backed inference via IronClaw and NEAR AI Cloud, lets an agent handle sensitive data, credentials, and trades without exposing them to the model provider, the infrastructure host, or the public chain. Because NEAR accounts are decoupled from their cryptography, the post-quantum signing it shipped in 2026 means agent identities meant to run for decades can survive a cryptographic transition their keys otherwise could not.
Ethereum: Settlement, Value, and Institutional Trust
Ethereum's homepage frames it as "the internet that belongs to you," and the pitch is ownership and permanence. A credibly neutral network that has run since 2015 without a second of downtime, that no company controls, and where your assets, identity, and data are held directly. That is the foundation of what Ethereum actually is, the settlement layer of crypto. It secures the most value, has the deepest liquidity (Uniswap, Aave, Morpho, Pendle), defines token standards the whole industry adopts (ERC-20, ERC-721, ERC-4626), and is the one of the few chain institutions recognize and trust. Its L2 ecosystem, Arbitrum, Optimism, Base, RobinHood Chain, extends that surface area, offering cheaper execution environments that settle back to Ethereum for security.
The strengths are real and deep. Ethereum has one of the largest developer ecosystems, some of the best tooling, and the most audited contracts in crypto. The EVM remains one of the most consequential innovations in the space's history, and the ERC token standards built on top of it created network effects that are now extremely hard to dislodge. For storing value, settling high-value transactions, and giving institutions a neutral base layer to build tokenized finance on, Ethereum remains the answer.
But the same design that makes Ethereum a superb settlement layer makes it an awkward substrate for the agent economy. Its scaling lives across many L2s, each with its own bridge, security assumptions, and liquidity makes it an archipelago, not a single environment. Native account abstraction, which would give agents scoped, programmable identity out of the box, is still years and several competing proposals away. Ethereum's rollup-centric roadmap was explicitly built to scale human transaction throughput and institutional settlement, not to be the unified, identity-rich, low-latency coordination layer that agents transacting across chains require. It is the bedrock the ecosystem settles on, it is not, by its own design choices, where autonomous agents will natively live.
Solana: Memes, Trading, and Retail Velocity
Solana's homepage now calls it "the capital market for every asset on Earth," and the phrase captures both its ambition and its center of gravity. In practice, Solana is the chain of velocity: the dominant venue for memecoin launches, Pump.fun alone has minted millions of tokens, for high-frequency retail trading, and increasingly for the tokenization of equities and real-world assets, where it has captured a meaningful share of onchain tokenized-stock volume via xStocks. The core user loop is simple and fast: trade, speculate, settle, repeat. Solana is engineered end to end to make that loop as easy and cheap as possible, and it is arguably the best chain in crypto at exactly this.
The architecture fits the use case cleanly. Sub-second (~400 ms) blocks and single-shard parallel execution absorbs bursty, high-volume trading. Transaction costs are a fraction of Ethereum L1's, and the account model, stateless programs operating over accounts passed in at call time, is ideal for the simple, high-throughput token contracts that trading and issuance depend on. Firedancer's pursuit of far higher throughput is a bet on the same thesis: make the venue faster and cheaper still, so more of the world's trading can move onchain. On its own terms, this is a coherent and successful design.
But that optimization also defines a ceiling. Solana is built for a world where a human is in the loop, a person, or a bot acting on a tightly scoped mandate, clicking trade against a single high-performance ledger. It is not architected for the harder problem the agent economy poses: autonomous software that holds its own accounts, carries granular permissions, remembers state across long-running tasks, and orchestrates multi-step plans across many chains. Cross-chain awareness is not native. Identity and scoped authority are not first-class. Asynchronous, cross-chain composability, the substrate agents actually run on, sits outside its design. Solana is the fastest place to trade an asset, it is not, by construction, the coordination layer for software that transacts on its own behalf across the whole ecosystem.
Zcash: Private Money
Zcash is the most technically credible private-payments system ever created. Its shielded transactions use Halo 2 zero-knowledge proofs, no trusted setup to hide sender, receiver, and amount onchain while keeping the ledger verifiable. This is digital cash in the cypherpunk tradition, and in 2026 that tradition found new momentum. A new wave of prominent advocacy (Naval Ravikant's "Zcash is insurance against Bitcoin," Balaji Srinivasan's scaling push) and fresh capital (a $25M ZODL raise backed by a16z, Paradigm, Coinbase Ventures, and others) have made private money one of the cycle's most attractive narratives, with Zcash as a clear expression.
The technology backs the story. Halo 2 is state-of-the-art for shielded transactions, and the NU7 roadmap sharpens Zcash for its purpose. Zcash Shielded Assets would extend private issuance beyond ZEC, and explicit fees with fee burning aim at a sustainable economic model. Project Tachyon's push toward payments-scale shielded throughput takes the historical bottleneck head-on. Within its chosen lane, cryptographically private value transfer, Zcash is the best in crypto, and it is getting better.
But that lane is narrow by design. Zcash has no general-purpose smart contracts, no programmable account logic, no composable DeFi, and no native cross-chain coordination. This is a deliberate specialization, not an unfinished roadmap, Zcash is a purpose-built instrument, not a platform. Which is precisely why its relationship to the connective layer matters. As the interoperability section showed, when Zcash reaches the rest of the economy it increasingly does so through NEAR. The division of labor is clean, Zcash supplies one of the best private money in crypto, and NEAR supplies the rails that let that private money move through the wider economy without surrendering its privacy. They complement each other.
Fused for the Future
The industry is approaching an inflection point. The first wave (2015-2022) was broadly speculation, people trading tokens on narratives. The second wave (2022-2026) was infrastructure maturity, sharding, account abstraction, scalability, the work this report has spent most of its length examining. The third wave (Now) will be autonomous agents. Agents that hold assets, make decisions, execute transactions, and coordinate with one another. Each chain examined here has a native competency, and my read is not that one wins today, but that they specialize.
When the agent wave arrives, the chain that matters most will not be the one with the fastest memes or the deepest liquidity. It will be the one that can host millions of agent identities under human-readable names, process billions of micro-transactions a day across shards, let an agent act on any chain from a single account, give users native control over agent permissions through programmable keys, and guarantee post-quantum security for agent accounts that may run forever.
Most layer 1’s are infrastructure for what humans do today. NEAR is infrastructure for what agents will do tomorrow.
Conclusion
The central finding of this analysis is that NEAR Protocol has already shipped, to mainnet, a set of capabilities that Ethereum, Solana, and Zcash are actively working toward reaching over the next 1-4 years. The architectural bet NEAR made on day 0, is paying off in the only metric that matters for infrastructure and the agent economy: production reality.
The horizon gap is closing for other chains, but NEAR is already there.
