TechFlow Logo
Login/ Sign up
ETH Gas
Gwei
Fear
gas
Who Defined Ethereum? Cultural Convergence and the Truth of Crypto

Who Defined Ethereum? Cultural Convergence and the Truth of Crypto

2026.09.29
Share
From Code Consensus to Shared Computational Reality: A Philosophical Reflection.

Written by: Conall O'Reilly

Translated by: Saoirse, Foresight News

Ethereum is a philosophical revolution, and a cultural consensus built upon universal, shared, and neutral infrastructure. But on a practical level, it is a set of software tools and a continuously advancing R&D endeavor, providing us with the technical mechanisms to realize this vision. Various software specifications, engineering implementations, and relentless research efforts collectively form the Ethereum protocol we recognize.

Philosophy Crystallized into Code

Language carries human reason, philosophy, and thought. Yet any expression used to articulate an idea inherently simplifies the idea itself; descriptive tools ultimately have limited expressive power. The core ideology of Ethereum can be concretely expressed through formal languages: mathematical symbols, logical computational architectures, and programming code. The Ethereum protocol emerged precisely as a product of humanity's exploration into how Ethereum's ideals can take root in the real world. If we view the Ethereum protocol as a shared computational reality, its establishment rests on three ontological pillars:

  • Cultural Convergence: Collaborating across cultural and social dimensions to reach a consensus on the universal definition of the Ethereum protocol.
  • Cryptographic Truth: The Ethereum protocol defines what constitutes "truth" internally within the system.
  • Majoritarian Representation: A social credential existing outside the Ethereum ecosystem operates via cryptographic notarization on the network to determine the majoritarian stance corresponding to the consensus reached in this shared reality.

All parties form a cultural consensus around the protocol definition, thereby establishing a truth standard verifiable through cryptography. The majoritarian mechanism enables all participants to collaboratively reach a consensus: Ethereum possesses an instantaneous state that defines its current existence; this state stems from the subjective perspective of observers, meaning observers must hold some form of representative credential from outside the system.

The cultural consensus formed around the protocol definition subsumes everything else; this is the root of why truth holds strong subjectivity, and the definition of truth itself is thus established. Weak subjectivity is equally important at higher levels: Ethereum observers can make assumptions based on cryptographic truth, establishing subjective axioms as the foundation for their other cognitions. The Ethereum network consists of numerous independent users running the same version of the Ethereum protocol implementation, exchanging information via communication layers like the internet. Protocol definitions combined with network and informational interactions drive Ethereum to continuously converge and update its protocol state. Every participant in the Ethereum network jointly converges on the network's instantaneous and deterministic state, relying on the initial protocol definition, cryptographic verification, and the majoritarian mechanism. The need for a majoritarian mechanism arises because the current state must be deterministically derived from a series of fixed operations in the network history; however, we cannot assume all observers receive events in the same order, so they must vote based on their respective observations. Thus, the Ethereum network, composed of thousands of computers running identical software, can reach a consensus on Ethereum's current "state," endowing it with a universal instantaneous definition that updates in real time according to user behavior.

The Human Collaboration Challenge

To evolve from a static technical definition into a continuously advancing, collaboratively operating network, the entire architecture is rooted in a cultural consensus at the protocol definition level; and this culture stems from the sum total of ideas held by all Ethereum adherents. The cultural paradox: Cryptography can determine correctness at a technical level, but culture has no formal standard for determining right and wrong — culture itself is its own standard. Many arguments supporting or opposing cultural change are inherently paradoxical and self-dissolving: one cannot argue that culture should change to accommodate other ideologies or ways of life, because the act of calling for change is itself part of the culture it seeks to alter.

There is also the governance paradox: If governance shapes culture, then what shapes governance? Is it that people first reach a cultural consensus and then formulate governance rules, or does a governance mechanism emerge first to manage and guide culture in a systematic or ideological manner?

Governance over the Ethereum protocol and its roadmap is essentially a human collaboration challenge: all parties must reach a consensus on the nature of the protocol and how it will be iterated and adjusted in the future. Once deprived of the cultural truth foundations built by entities like corporations and nations, this becomes incredibly difficult: how can alignment be reached if people cannot even unify their consensus goals or clarify what they are trying to agree upon? In the real world, such governance mechanisms often originate from straightforward geopolitical dynamics, such as "who possesses the greatest nuclear capability"; those wielding real power can influence or even dictate the subjective definitions of matters, including law and order. Ethereum, however, relies on soft power: decisions are typically driven by individuals who command cultural influence through precedent, deeply embrace Ethereum's philosophy, and are well-known within the ecosystem.

Within the ecosystem, there are many such influential entities: the Ethereum Foundation has long served as the de facto initiating institution for Ethereum's philosophy, wielding immense cultural influence. As of September 2025, 32 teams under 15 institutions maintain 13 distinct Ethereum protocol clients. These contributors of ideas and developers of the protocol collaborate to form the All Core Developers (ACD), where the governance rules for the Ethereum protocol are established. Related documents outline the design and review processes for Ethereum Improvement Proposals (EIPs) as well as the network upgrade workflow. Historically, ACD coordination has been relatively loose without formal definitions; to this day, our methods for organizing personnel and assigning roles rely more on practical exploration than codified mandates. In simple terms, the ACD's role is to coordinate the entire ecosystem and reach a consensus at specific junctures on software "forks" that modify the definition of the Ethereum protocol. The fork process includes: researchers and developers proposing software modifications, finalizing changes, conducting tests, publishing final specifications, developer teams completing code implementation, and finally network nodes enabling the changes on designated dates to achieve broad consensus. This fork development cycle tends to be lengthy, lasting several months to up to a year.

Architectural Principles of Computational Coordination

The core proposition of Ethereum: What does it truly mean to enable human collaboration through computation? The foundational truth defining this proposition is a set of ideas imbued with cultural and philosophical depth. But the answer to this ontological question lies in a technical and architectural solution. Ultimately, we must translate this philosophy into a tangible software protocol to answer the questions posed by Ethereum. The attributes of the protocol itself are constrained by our understanding of this philosophy. In other words, we must let the vision serve as our guiding light; otherwise, Ethereum will lose its cultural anchor, and the protocol will devolve into a hollow framework seeking ideology. We must derive from first principles to ultimately construct this protocol.

If Ethereum itself is a question, what is it? Defined earlier: Ethereum explores the meaning of "existence" within the context of computational collaboration. The goal is to transform the abstract concept of a Turing machine into an interactive domain possessing computational existence. Simply put: autonomous sovereignty holds true at the local level, allowing human users to observe a computational world existing solely on their local machine, granting them complete autonomy over this locally bound, strongly subjective ontology. When expanding the perspective to multiple observers, a minimum threshold of strong subjective consensus is required to allow people to observe and interact within a broader interpersonal space. All observers inherently define truth subjectively within their respective local environments. Information and data carry no inherent meaning; definitions and perspectives impart meaning. However, truth is built upon scarcity: if any observer can repeat a statement infinitely, that statement cannot be considered true. Therefore, the foundation of collaboration is reaching a consensus on definitions, and guaranteeing that true statements possess scarcity within this framework of correctness.

The general form of collaboration is more abstract; the example of digital cash clearly reveals the essence of this collaborative game: currency is a simple collaborative game where every participant holds a balance; only the controller of the balance can initiate authorized transactions to deduct from their own balance and credit another's equivalently. For N users to participate in this balance collaboration game, two things must be accomplished: a) reaching a consensus on the game itself (e.g., programming rules, cryptographic tools used); b) using these tools to verify the correctness of the game's instantaneous state and continuously advance the game along the time dimension. Cryptographic tools construct the spatial dimension, creating the necessary scarcity for truth. Technically, balances are tracked by accounts, each possessing a cryptographic identity like a public key; users safeguard private keys, ensuring only transactions initiated by the balance owner are valid, thereby guaranteeing operational scarcity. There also exists the time dimension: to determine everyone's current balance, the chronological order of all historical transactions must be clarified; otherwise, the feasibility of past events cannot be judged.

This described collaborative game is necessarily embedded within the execution logic of a Turing machine: it is a computational game comprising storage (balances) and execution (transactions). While such collaborative games are certainly useful, abstracting a collaborative model atop a Universal Turing Machine offers a fundamental advantage — it can run all computable games without restriction.

This demonstrates that collaboration requires two meta-dimensions: the cryptographic spatial dimension that creates truth scarcity, and the temporal dimension that imposes sequence upon the collaborative game. Both not only define instantaneous states but also project future states. These two foundational components are what we call consensus. Serving as the truthful bedrock supporting the ontological existence of the computational realm and enabling collaboration, consensus is indivisible. Intuitively, consensus as an architectural objective is the core of Ethereum's ontology; it envelops the entire system and cannot be further abstracted.

With this, we can distill a streamlined underlying architecture that summarizes the essence of Ethereum from an ontological perspective: built upon a Turing-complete computational model, predetermining the cryptographic spatial dimension to guarantee the scarcity of machine operations; adding addressable computational storage to define various operations acting upon the storage; and finally encapsulating everything within the time dimension, allowing us to form structured truths about machine states at different points in time. In plain terms: "Various entities reside within addresses, and these entities can change over time according to operations initiated by users of those addresses." Leveraging Turing-complete execution capabilities, these operations can encompass any generic computational behavior.

Ethereum in Reality

From a pragmatic perspective on Ethereum's actual technical architecture: for the Ethereum protocol to materialize, it requires large-scale distributed deployment. There is no central coordinating party; Ethereum is a network composed of countless computers collaborating in real time. Since consensus is indivisible, we treat it as an architectural axiom and begin here: a group of computers jointly confirms the current state of an entity and collaborates in real time to process state changes generated over time. The carrier of this continuously changing state is the Ethereum Virtual Machine (EVM); state changes originate from universal operations initiated by users within the network. We can describe the EVM by defining storage first, then execution: storage consists of program code and arbitrary data, addressed via pointers and bound to cryptographic identities. Operations initiated against storage externally are broadcast across the network as messages, achieving collaboration through predetermined consensus.

The definition of execution is fascinating: the execution results of a Turing machine are inherently unpredictable. To achieve deterministic computation on the EVM, the calculation process must occur somewhere. However, verifying whether execution results are correct is algorithmically distinct from the original computation itself; verification complexity does not scale proportionally with computational complexity. Therefore, the bottleneck for proving execution correctness lies in data, not computing power; computing power is merely used to generate results, while verification requires minimal compute. This means we can reach consensus on universal executions of any scale, with the sole limitation being the network's capacity to store and transmit data. Data is a finite resource, necessitating rate-limiting mechanisms to convert network data capacity into a measurable resource.

Turing completeness implies no upper limit to the set of executable operations. Hardcoding these into the architecture or building precompiles directly into the EVM would unnecessarily restrict collaborative behaviors possible on Ethereum. The ultimate design goal of the EVM is extreme generalization and abstraction, where any implementable functionality can be accomplished through code. Even cryptographic identities themselves can be abstracted: EVM code associated with an address can invoke any custom validation function rather than being confined to hardcoded public key systems. Not only computational behaviors require abstraction, but the existential forms of execution and storage on Ethereum must also be generalized to form a complete spectrum of "existential" possibilities within the Ethereum context. Unlike Ethereum which is wrapped in consensus and possesses closed existential boundaries, the physical universe naturally lends existence a localized quality. In Ethereum, knowledge is global, with all execution and storage ultimately converging onto a single root of consensus truth. Yet only the verification phase requires global execution; ideally, computation itself is kept as localized as possible. Storage and data cannot be eliminated and must exist globally; but they can be compressed into cryptographic proofs incorporated into consensus, eliminating the need for raw data replication across the network. We adopt a generalized design for data availability: utilizing economic metrics to render data temporary, complemented by network sharding. Even if the network achieves global consensus on "data availability," the scope of access to the data itself can remain private. The same logic applies to execution: only operations whose execution paths intersect at the same address need to compute within the same local view; all mutually exclusive paths and sub-paths can execute calculations to the maximum extent in parallel within their respective scopes, coordinated by network observers on demand. Distributed execution and data throughput achieve uniform distribution, realizing the generalization of execution and data availability at the architectural level. The ingestion, ordering, and privacy protection of base-layer throughput are handled through multithreaded coordination across the entire network, rather than every node replicating and executing a single sequential thread.

Limits of Cryptographic Truth

Fundamentally, the source of truth defining correctness within the Ethereum system is the cultural consensus formed around the protocol definition (defining what the network can become). But alone, this cannot define what the network actually is in reality. The genuine state of the network since genesis must be derived using information external to the system; this information records the historical actions of all observers and the majority's perception of event sequencing. Given an instantaneous state and a set of operations, we can judge whether operations generating a new state conform to protocol definitions; yet we cannot verify whether these operations and their timing will be collectively endorsed by a broader Ethereum observer community — this is the consensus problem.

Ethereum's spatial dimension is built upon cryptography and underlying protocol components, ensuring operations on the state machine can be statically verified; but whether these operations occurred and when they occurred depend on the subjective perceptions of network observers. This implies Ethereum must define "observers" to gauge majoritarian representation and thereby interpret events generating the network's instantaneous state. Ethereum's uniqueness lies in the cultural ambiguity surrounding the definition of observers, where vast amounts of information are lost within the strong subjectivity introduced by the Genesis Block.

Contrast this with Bitcoin: during the genesis phase, there existed only a static protocol definition; even the Genesis Block reward was unspendable, and the protocol hardcoded no external systemic prerequisites. Even with Satoshi Nakamoto's pre-mined tokens, under proof-of-work consensus, observers' cognitive definitions maintained cultural homogeneity, stemming from external energy investments. Ethereum's pre-mine, however, effectively established a rule: the realistic definition and instantaneous state of the modern Beacon Chain are, to a certain extent, constrained by the definitions of the built-in Genesis Block observers (staked ETH).

The core logic: strong subjectivity and the definition of observers must originate externally. Consortium chains and centralized systems hardcode operator roles within the protocol, subjectively presetting observers beforehand. Systems like Bitcoin, conversely, only presuppose protocol definitions, relying on external universal culture to define observers and form majority cognitions. For instance, Bitcoin defines the network's realistic state as the chain confirmed by the highest computational power consumed; its observer ontology is culturally homogeneous, highly abstract, and closer to the universe itself. Up to 2022, Ethereum similarly utilized proof-of-work before transitioning to proof-of-stake, constructing a universal culture for observer cognition reliant on Ethereum's internal ETH scarcity. However, proof-of-stake uses system-endogenous tokens as observer proxies, rendering the token ontology equivalent to the observer ontology, leaving the issue of subjective representation unresolved. Networks that pre-mine stakable tokens at genesis encounter the exact same problems as centralized systems: the definition of observers existed prior to the Genesis Block's creation and was baked into the protocol, making it impossible to achieve a truly universal culture. Contemporary Ethereum is only partially affected by this issue: of the current 122 million ETH, 72 million originated from the pre-mine. This implies that proof-of-stake majority cognitions will inherently skew, as specific entities were subjectively bestowed observer status from inception. The remaining 50 million came from proof-of-work mining; their utilization within the proof-of-stake framework can be understood as reusing the ontology formed by those historical external energy investments.

This illustrates: instantaneous protocol states originate from an observer ontology that delineates majority cognition. The Beacon Chain is a component within the Ethereum protocol, serving as the truthful bedrock for deriving instantaneous realistic states, operating through the following workflow: Genesis: Starting from the genesis state, stake distributions and the initial states of the network and virtual machine are preset. Ethereum's 2022 proof-of-stake genesis inherited the state of the 2016 original proof-of-work network. Simultaneously, a validator registry is configured, allowing validators to gain voting rights by staking tokens.

  • History: Tracing all votes cast by staked observers regarding network states to chronicle the formation of observer cognition; sequentially accepting user behaviors perceived by the network and arriving at consensus, acknowledging the majority's recognized event sequences and existential realities as true, while still allowing us to conduct independent cryptographic verification.
  • Current State: Reaching the latest network state acknowledged by the majority, i.e., achieving consensus, and sharing normative state cognition regarding the virtual machine and staked validator registry with Ethereum observers.
  • State Transition: At the apex of the normative history, we vote alongside other observers to collaboratively determine the next normative state based on users' real-time actions within the virtual machine.

A subjective genesis state could alternatively select recent checkpoints we subjectively deem valid. The definitions of both the network itself and the genesis state are intrinsically linked to our strong subjective cognitions. Relying on protocol presuppositions to accept recent truth assumptions like "I consider this historical checkpoint valid" constitutes weak subjectivity: essentially, it means affirming a specific statement as true within the subjective context provided by protocol definitions.

The protocol's trust assumption: An observer supermajority (2/3) measured by stake volume maintains honesty according to protocol-defined standards of honesty (including unintentional dishonest acts within this definition). Provided this condition holds at any given moment, the network can reach consensus on the current normative state; conversely, external observers cannot distinguish whether the current state derives from a legitimate normative history or one tampered with and rewritten by a malicious staked supermajority. Therefore, regardless of what network state you observe, you can only verify that the state is cryptographically possible, but you cannot prove that the history generating the current state represents the cognition of an honest majority. The issue of historical cryptographic validity grows even more nuanced: the assumption of honest staked majority applies not only to chain structure but to all behaviors occurring in history. That is to say, whether historical events are correct holds true solely within the subjective context of the honest majority. If the staked majority chooses to endorse a cryptographically invalid historical event, it signifies the staked majority has ceased to be honest, the assumption fails, and the validity of everything becomes blurred. Thus, we invariably assume an honest majority exists; since this assumption underpins all other validity, merely performing cryptographic verification on history without trusting the majority holds no practical merit. Practice confirms this: when a historically "invalid" event appears in the normative history under your protocol definition, you cannot differentiate whether it constitutes malicious state tampering or a synchronized network-wide hard fork upgrade that your outdated software simply cannot recognize. The DAO Fork stands as a quintessential case study: the majority chose to endorse this cryptographically invalid event, baking it into the normative history. By old protocol definitions, it is invalid; yet subjectively, the majority affirms it belongs to the main chain history.

In summary: cryptographic verification inherently possesses limitations. Within the protocol's definitional framework regarding validity and honesty, consensus enables the honest majority to collaboratively align; yet "what constitutes honesty" is itself a subjective concept, paradoxically dictated by what the majority deems true. This reiterates that Ethereum's definition inherently carries subjectivity, requiring you to interpret what constitutes truth. Even if you disagree with the network's majority, no one can dictate that your definition of Ethereum is less correct than others'.

Ontology Simplified into Engineering Implementation

Summarizing the preceding discussion: culture reaches consensus at the protocol definition level, serving as the initial subjective axiom of truth that delineates correctness within the protocol's own rules. From this emerges a universally runnable virtual machine architecture; leveraging the majoritarian mechanism formed by external observer ontologies generates consensus, elevating Ethereum into a globally shared computational reality . The network's actual operational logic: users broadcast universal operations to the shared VM, network computers sort these operations and vote on their temporal sequence, allowing the entire network to jointly derive Ethereum's instantaneous state.

Culture is multifaceted and this revolution is far from flawless, yet numerous pathways exist to participate in realizing Ethereum's vision. The status quo maintained by the ACD merely represents a narrow perspective on defining Ethereum. You may entirely propose divergent viewpoints, even altering the public's pervasive conception of a world computer. Should you wish to join, the doors remain perpetually open.

If you believe in freedom, welcome to the future. It is built upon Ethereum.