| Publisher | Monad documentation |
|---|---|
| Document | Living technical documentation, reviewed 2026-10-11 |
| Project | Monad |
| Documentation license | Not stated in the documentation reviewed |
| Official source | Monad for Developers documentation |
This is an educational summary of Monad’s changing technical documentation, not a reproduction of a single 2024 whitepaper. Features, measurements, and network parameters can change. The project’s code license is separate from the documentation’s license.
Monad is an Ethereum-compatible layer-1 blockchain whose public mainnet launched on November 24, 2025. Its design combines ordered EVM transactions with optimistic parallel execution, pipelined consensus and execution, a custom state database, and MonadBFT. This page summarizes the project’s living documentation as reviewed on October 11, 2026; it is not a fixed, individually authored 2024 paper.
How to read Monad’s performance figures
Monad’s documentation describes 10,000-plus transactions per second as a design-capacity figure for typical transactions. Capacity is not the same as traffic actually being used by applications. Real throughput depends on transaction types, gas consumption, conflicts over shared state, network conditions, and user demand. The same documentation reports a mean mainnet block time of about 302 milliseconds in September 2026. That is a project-published observation for a stated period, not an independent benchmark.
The protocol’s timing terms also need to be kept separate. Monad’s docs specify one 300-millisecond slot for speculative finality and two slots, or 600 milliseconds, for full finality. A block shown as speculatively final is not described as absolutely irreversible: the protocol documents a rare reversion case tied to provable equivocation by the original leader. Full finality is the stronger confirmation point. These are protocol parameters; actual user-perceived confirmation can also depend on wallets, RPC providers, and applications.
Parallel execution preserves transaction order
Monad does not remove ordering from the EVM. A block contains a linearly ordered list of transactions, and the intended state is the result that would follow from applying that list in order. Parallel execution is an optimization for calculating that result faster; it does not mean that transactions may permanently take effect in any order.
In the optimistic approach described by Monad, multiple workers begin executing transactions before all earlier work has finished. Each result records the state it read and the updates it wants to make. As results are committed in the block’s original order, the system checks whether each transaction’s inputs still match the state available at that point. If an earlier transaction changed a value that a later transaction relied on, the later result can be rescheduled and executed again against the correct state.
This can save time when transactions touch independent accounts or storage. It can provide less benefit when many transactions contend for the same state, because conflicts require additional work. The documentation’s guarantee is serially equivalent results for the ordered block, not a promise that every transaction runs in parallel or that every workload reaches the advertised capacity.
Consensus and execution run as a pipeline
Monad also separates agreement on transaction order from the work of executing that order. Its nodes can reach consensus on a block’s ordered transactions while execution of a previous block is still underway, then continue consensus on later blocks. This pipeline gives execution more time than a design that must finish every state update before consensus can advance.
The separation does not make execution optional. Full nodes still need to process the transactions deterministically and check the resulting state. Monad’s documentation describes delayed state-root verification as one part of this design. The distinction is useful: consensus determines the canonical order, while execution calculates and checks the state that order produces.
MonadBFT and the meaning of finality
MonadBFT is the project’s proof-of-stake Byzantine fault-tolerant consensus protocol. The documentation describes it as part of the HotStuff family and highlights linear message complexity in the normal, failure-free case, optimistic responsiveness, and protection against “tail-forking.” Tail-forking is a failure mode in some pipelined leader-based protocols where a later leader can discard a predecessor’s block. These are protocol-design claims from the project; the research paper and code provide more technical detail, but they are not a substitute for independent review of the live network.
Monad’s use of “speculative finality” is narrower than full finality. One consensus round can allow participants to act on an ordered block sooner, but a rare equivocation case can still require a reversion. The project’s configuration says full finality takes two 300-millisecond slots. Describing both milestones as “irreversible after one block” would blur an important distinction.
What MonadDb changes
MonadDb is a custom key-value database designed for blockchain state and other authenticated data. Ethereum state is organized using a Merkle Patricia Trie. MonadDb stores Patricia-trie nodes natively rather than placing that structure inside a generic database tree, and the documentation also describes asynchronous input/output, in-memory caching, versioned state, and compaction.
It is therefore misleading to say that MonadDb “replaces Ethereum’s Merkle Patricia Trie.” The trie remains central to the authenticated state representation; MonadDb changes how trie data is stored and accessed. A bespoke database can be tuned to the project’s workload, while adding implementation complexity and making storage behavior another part of the system that operators and developers must understand.
EVM compatibility and what developers still need to test
Monad’s documentation says its client supports Ethereum-compatible EVM bytecode and Ethereum-style JSON-RPC interfaces. That makes familiar wallets and development tools relevant, and it can reduce the work of moving an existing contract. The same documentation lists network-specific behavior and parameters, including a different chain ID, gas rules, and its own precompile and storage details. Compatibility is not a guarantee that every application can be redeployed without testing or that every provider exposes identical behavior.
The project’s current documentation identifies its consensus and execution client code as open source under GPL-3.0. That license applies to the repositories’ code; it does not establish the license of the separate living documentation, which does not state a documentation license on the pages reviewed here.
Performance goals and decentralization trade-offs
Monad presents software design as a way to improve performance without relying on unusually powerful or geographically concentrated nodes. However, its current node-operations guide calls for a 16-core CPU with a 4.5 GHz or higher base clock, at least 32 GB of RAM, dedicated NVMe storage, and bare-metal operation; it says cloud environments are not officially supported. These requirements are relevant when assessing who can practically run a node. They do not, on their own, prove that the network is centralized or decentralized. A careful assessment would also examine the live validator set, stake distribution, uptime, governance, and how requirements evolve.
The main trade-offs are concrete: optimistic parallelism may re-execute conflicting work; specialized storage can improve a target workload while increasing system complexity; fast consensus depends on tight timing; and EVM compatibility still coexists with chain-specific execution and infrastructure. The 10,000-plus TPS number should be read as the project’s stated capacity for typical transactions, while real throughput and decentralization need ongoing measurement.
Social Media Sentiment
Reddit discussions around Monad’s launch showed a mixed, self-selected sample. Supportive comments focused on its EVM compatibility and the possibility that parallel execution and fast confirmation could attract developers. Skeptical posts questioned whether actual application use and ecosystem activity would match the technical-capacity story, and raised concerns about token distribution, valuation, and post-launch user retention. Replies disagreed about how quickly a new network should be judged and whether its technical design would translate into durable use. These threads show themes in a few communities; they are not a representative survey, independent performance data, or investment guidance.
Last updated: 2026-10
Related Terms
See Also
- Aptos: A Safe, Scalable and Upgradeable Smart Contract Platform
- Sei: A High-Performance Layer-1 Blockchain for Trading
- Sui: A Layer-1 Blockchain Using the Move Programming Language
Sources
- Monad Documentation: Introduction — Identifies Monad’s architecture and records the public mainnet launch date; project documentation, not an independent assessment.
- Why Monad: Decentralization + Performance — Separates the stated 10,000-plus TPS capacity from observed mainnet figures and reports the mean block time for September 2026.
- Monad for Developers — Summarizes transactions, EVM compatibility, consensus, execution, MonadDb, network-specific behavior, and code licensing.
- Parallel Execution — Explains optimistic execution, ordered commits, validation of read inputs, and re-execution when state conflicts occur.
- MonadBFT — Describes the protocol’s one-slot speculative and two-slot full-finality configuration, plus its stated consensus properties.
- MonadBFT: Fast, Responsive, Fork-Resistant Streamlined Consensus — Research paper by Mohammad Mussadiq Jalalzai and coauthors; submitted in 2025 and revised in July 2026.
- MonadDb — Describes the custom key-value store, native Patricia-trie storage, asynchronous I/O, and state retention.
- Monad Node Hardware Requirements — Lists current CPU, memory, storage, bandwidth, and bare-metal guidance from the project.
- Category Labs: Monad Execution Repository — Identifies the execution client and its repository license; code licensing should not be confused with documentation licensing.
- “Monad thoughts..” (r/CryptoCurrency) — A launch-period discussion that raised both technical optimism and questions about token distribution and valuation.
- “Is Monad Slowly Heading Toward Becoming a Dead Chain?” (r/Monad) — A skeptical post-launch thread about ecosystem activity; replies disputed whether the network could fairly be judged so soon.