Mainframe operates through a network of miners and validators that collaborate and compete to perform protein folding simulations. The workflow and incentive structure are carefully designed to ensure useful work is done and the best results are rewarded in TAO tokens. A typical cycle on Subnet 25 works as follows:

Job Creation: Validator nodes (the evaluators) randomly select a protein structure from large public databases (such as the Protein Data Bank). The validator downloads the protein’s data (e.g. atomic coordinates) and sets up a molecular dynamics simulation input – essentially preparing a “folding job.” This job is then announced to the network.

Miner Selection: Validators first broadcast a ping (PingSynapse) to all miners to discover who is available and capable of handling the job. Miners that respond are considered candidates. The validator then uses a job assignment synapse (JobSubmissionSynapse) to dispatch the prepared protein-folding task to a subset of those miners (for example, 10 miners might be randomly selected for the same job). Multiple miners are deliberately assigned to the same protein task – an oversubscription strategy that creates competition and redundancy, ensuring there’s a high chance someone finds an optimal solution.

Mining (Protein Folding Simulation): Each chosen miner node runs the protein folding simulation on its own hardware. Mainframe leverages industry-standard molecular dynamics software (such as GROMACS and OpenMM) to simulate the physical movements of the protein’s atoms over time. Miners typically use GPU-accelerated computing for this, since MD simulations are computationally heavy (Mainframe’s base miner setup assumes CUDA-capable GPUs to meet a performance baseline). The simulation starts from the protein’s initial 3D structure (often an unfolded or partially folded state), places it in a virtual solvent environment, and then computes how the structure evolves and folds over a series of time steps. Each miner uses a different random seed in the simulation, causing their trajectories through “folding space” to diverge. In effect, the miners are all exploring the protein’s energy landscape in parallel, searching for a low-energy conformation (the folded, stable structure). The goal for miners is to produce a protein configuration with the minimum possible free energy, since lower energy corresponds to a more stable (better folded) protein structure. Throughout this process, miners periodically send updates or can be probed by validators to report interim results (e.g. the best energy found so far).

Validation and Scoring: The validator monitors the progress of all miners working on its job. Using the same molecular dynamics toolkit, the validator can calculate the energy of each submitted protein structure to objectively compare results. This energy-based scoring is transparent and deterministic – given a protein configuration, anyone can compute its potential energy using standard physics formulas, so both miners and validators can agree on what result is best. The validator also performs integrity checks: it ensures the results returned by miners correspond to the exact protein and simulation parameters that were assigned. This step closes any loopholes where a miner might try to cheat, because the validator will reject results that don’t match the expected input files or that appear suspicious. Once the simulation time is up or the protein reaches a stable state, the validator has a record of the lowest energy achieved by each miner.

Rewarding the Best Result: After evaluating outcomes, the validator uses Bittensor’s incentive mechanism to assign TAO rewards to the miners. The rewards are weighted heavily toward the miner that found the lowest-energy (i.e. best) structure for that protein. In the current design, the top-performing miner on a given job earns about 80% of the total reward allocated to that job, while the remaining 20% is split among the runners-up according to their relative performance. (The team has indicated this may move to a true winner-takes-all model soon to further encourage innovation and competition.) Importantly, if multiple miners submit identical or extremely similar final results (for example, two miners ended up folding the protein to the same conformation), the network penalizes duplicates – those miners would receive zero reward for that job. This rule ensures miners aren’t simply copying each other or converging on trivial solutions, and it incentivizes each miner to explore a unique trajectory in the simulation. The validator’s reward assignment is then recorded on-chain via Bittensor’s Subtensor module (updating the miners’ “scores” or weights in the metagraph for Subnet 25).

Incentive Safeguards and Iteration: Mainframe’s incentive mechanism includes several safeguards to make the system efficient and attack-resistant. For one, validators employ early stopping: if no miner in a job is able to improve the protein’s energy (find a lower energy state) for a certain period (currently ~1 hour) the job is terminated early. This prevents wasteful computation on a folding task that has stagnated. Additionally, an epsilon-bounded improvement criterion is used – essentially the network defines a minimum meaningful energy drop (epsilon) that must be achieved for a result to count as a true improvement. This epsilon is calibrated based on the protein’s complexity (using heuristics developed by the team) so that miners can’t game the system by submitting infinitesimally small improvements; only substantive progress earns rewards. With these measures, the network encourages miners to continuously strive for significant breakthroughs in lowering energy. After a job concludes and rewards are given, validators will queue up new protein jobs and the cycle repeats, continually driving the decentralized folding supercomputer forward.

Through this process, Subnet 25 maintains an effectively unbounded throughput for work. Because each validator can queue multiple jobs (each job assigned to many miners), and multiple validators operate in parallel, the subnet can scale to hundreds or thousands of simultaneous protein folding simulations. In practice, with the current network of validators, Mainframe runs on the order of 1,000+ concurrent simulations at any time. This level of parallelism – achieved by harnessing globally distributed GPUs – is what enables Mainframe to complete in days what might take a centralized lab weeks or months. The incentive design ensures that miners are motivated to invest in better hardware and algorithms: those who deliver faster and better folding results (i.e. find lower-energy structures more consistently) will accumulate more TAO and weight in the network, increasing their future earnings. Meanwhile, validators (who themselves have to stake and maintain reputation) are motivated to fairly and accurately judge miners, since their role in the consensus and reward process is critical to the subnet’s integrity. Overall, this synergy of miners and validators in Subnet 25 creates a positive feedback loop: better science → better rewards, which attracts better participants, leading to even better science.

Products and Applications (User-Facing Tools)

From a user’s perspective, Subnet 25 – Mainframe can be accessed and utilized through various tools that the Macrocosmos team has built on top of the raw network. The goal is to make the decentralized compute power of Mainframe available to researchers, developers, and even other algorithms via APIs and interfaces, rather than requiring everyone to run a Bittensor node. Here are the key products and deliverables associated with the subnet:

Folding API: Mainframe provides a RESTful HTTP API that allows external clients to submit protein folding jobs and retrieve results programmatically. This Folding API is implemented using FastAPI (a high-performance Python web framework) and acts as a bridge between users and the network of validators/miners. Through this API, a scientist could, for example, send a protein structure file (in a standard format) to the network and ask it to simulate folding that protein. The request goes to an API server which then interacts with the Bittensor Subnet 25 validators behind the scenes. The API handles job submission, status tracking, and result retrieval in a user-friendly way. Rather than dealing with blockchain transactions or low-level network calls, users can simply use HTTP requests (or an SDK) to harness Mainframe’s compute power. The API is designed with a Validator Registry and a Subtensor Service component that together figure out which validators are available and ensure the job is injected into the subnet properly. Results come back through the validators and are delivered to the client via the API when ready. This effectively turns Mainframe into a decentralized “Folding-as-a-Service” platform.

Organic vs Synthetic Jobs: Mainframe distinguishes between validator-generated tasks and user-requested tasks, and it exposes different endpoints for them. So-called synthetic jobs are the ones validators create on their own (as described earlier) to continuously benchmark miners. In contrast, organic jobs refer to real folding tasks submitted by outside users that reflect genuine scientific inquiries. The Organic API is the interface for these user-driven tasks. Authorized users (with API keys) can submit a specific protein they care about – say a protein related to a disease or a protein-ligand complex they want to analyze. The network will then process these jobs just like any other, except that they were externally requested. The separation is mainly logical; under the hood, both go through the same network, but it ensures that user jobs get properly injected and tracked instead of being lost among the endless synthetic validation tasks. The documentation emphasizes that organic tasks represent “genuine scientific interest in specific protein structures” and explains how those jobs are processed within the system. In short, Mainframe can fold proteins that you, the researcher, actually care about – not just random ones the network picks – which is a huge step toward practical utility.

API Authentication and Rate Limiting: Because Mainframe’s compute resources are valuable, access to the Folding/Organic APIs is gated by an API key system. Users (for example, research groups or companies) can request API keys, which the Macrocosmos team provides. These keys are used to authenticate requests, ensuring that only authorized jobs enter the network. Additionally, rate limiting is enforced – preventing any single user from overloading the subnet with too many requests at once. This is important for maintaining quality of service; Mainframe needs to balance external (organic) workload with the internal (synthetic) tasks that keep miners incentivized. The Macrocosmos documentation indicates that the API can be deployed in two modes: either embedded in a validator process or as a separate service communicating with validators via IPC. This flexibility means the interface can scale – one can run a dedicated API server cluster to handle many incoming user jobs, which then pipeline into the validator network efficiently. For most end users, however, these technical details are abstracted away. They interact with a simple endpoint – for example, submit a job and get back a job ID, poll an endpoint to check if the folding is done, then download the resulting folded structure once complete.

Constellation Dashboard: In addition to programmatic APIs, Macrocosmos has built a web-based platform (often referred to as Constellation) where users can explore and monitor the various subnets including Mainframe. On the Constellation app (accessible through Macrocosmos’s website), one can see live statistics and visualizations: for instance, the number of active miners and validators on Subnet 25, the number of proteins folded today, leaderboard of top-performing miners, etc. This provides transparency and a real-time view into Mainframe’s operations. It effectively serves as a dashboard for the decentralized supercomputer. The Mainframe section of the dashboard also highlights achievements – e.g., it prominently notes that since launch in mid-2024, over 400,000 protein-folding jobs have been completed on the network. Such figures help users appreciate the scale and reliability of the subnet. The dashboard likely also allows users to inspect specific jobs or even initiate simple folding tasks via a GUI (for those who prefer not to use the API directly). By making Mainframe accessible through a browser, Macrocosmos lowers the barrier for scientists who may not be familiar with blockchain: they can interact with the network’s results as easily as using a cloud service, but behind the scenes it’s fully decentralized.

Open-Source Code and SDK: Consistent with the project’s open ethos, all of Mainframe’s source code is publicly available. The miner software, validator code, and even the API server code are open-source under an MIT License. Developers or interested researchers can find these in the Macrocosmos GitHub repositories (the macrocosm-os/mainframe repo, and related ones like macrocosm-os/folding). This openness means anyone can run their own Mainframe miner node (if they have the hardware), contribute improvements, or fork the code for other uses. Macrocosmos also provides a Software Development Kit (SDK) for interacting with their subnets. The SDK likely includes helper functions to obtain API keys, submit jobs, and parse results, making it easier to integrate Mainframe into scientific workflows or pipelines. For example, a biotech company could integrate the Mainframe API into an automated pipeline that tests thousands of protein variants: the SDK would handle batching those requests and collecting the outcomes. All of this is in line with Macrocosmos’s philosophy of being an “open-source AI research lab” – they not only open their code but also share research updates on public forums (like Substack and Discord) so the community can learn and benefit.

Use Cases and Integrations: The primary “product” of Subnet 25 is, of course, folded protein structures and the data associated with those simulations (trajectories, energies, etc.). This is already directly useful to researchers studying those proteins. But beyond standalone usage, Mainframe can integrate into larger discovery pipelines. A notable application is in drug discovery workflows: for example, folding a protein to find its stable shape, then performing ligand docking (finding how a small molecule drug might bind to that protein). In fact, the team is actively moving toward supporting such workflows – a recent update teased that everything from “folding to docking [could happen] all on one subnet.” In collaboration with partners like Rowan Scientific, Mainframe’s output (folded structures and simulation data) is being used to train next-generation AI models known as neural network potentials (NNPs). These models (such as Rowan’s Egret-1) need large amounts of high-quality molecular simulation data (including quantum chemistry calculations via DFT). Instead of relying on a single supercomputer to generate that data, Rowan is tapping into Mainframe to dynamically generate datasets in a decentralized way. This is a novel use-case: Mainframe is not just solving one-off protein questions, but actually feeding into AI model development. It effectively becomes a backend compute layer for pharma and materials science applications. The fact that a biotech platform (Rowan) is integrating Mainframe via its APIs validates the product-market fit of Subnet 25’s deliverable – computational results as a service. We’re seeing the beginnings of a user-base beyond crypto, where scientists and companies leverage Mainframe’s outputs without needing to know the blockchain mechanics, simply through the provided tools and APIs. This real-world adoption is perhaps the strongest testament that Mainframe’s user-facing build is on the right track.

In summary, Mainframe’s “product” is twofold: (1) the computing service it provides (folding simulations on demand), and (2) the open platform it offers for the community (APIs, dashboards, and open-source code to engage with the subnet). These make it possible for an end-user to treat Subnet 25 like a decentralized cloud supercomputer – submit tasks, get results – while the complexity of incentivizing miners and maintaining the blockchain is handled under the hood. By delivering accessible tools, Mainframe bridges the gap between cutting-edge blockchain AI technology and practical scientific research needs.

Technical Architecture and Innovations

Under the hood, Subnet 25 – Mainframe is a fusion of blockchain-based coordination with high-performance scientific computing. Its architecture builds on Bittensor’s core framework of subnets and extends it with domain-specific modules to support molecular dynamics tasks. Let’s break down some of the key technical aspects and innovations of Mainframe’s design:

Bittensor Subnet Framework: At its base, Mainframe inherits the general subnet architecture of Bittensor. This means it operates on the Subtensor blockchain (a custom substrate-based chain) where all participating nodes (miners and validators) are registered with hotkey addresses and have stake (denominated in TAO) that determines their influence. The blockchain maintains a metagraph of all nodes in Subnet 25, tracking their weights (which reflect performance) and facilitating the incentive payouts. Mainframe leverages Bittensor’s modular design – where each subnet defines its own “work” and “validation” logic (in Mainframe’s case, protein folding). This modularity allowed Macrocosmos to plug in custom synapses and logic for MD simulations on top of the existing proof-of-stake and proof-of-learning mechanisms of Bittensor.

Custom Synapses for Job Distribution: Two specialized synapse implementations enable Mainframe’s workflow. The PingSynapse is a lightweight protocol call that validators use to discover available miners (essentially a heartbeat check across the network). It returns information on which miners respond and perhaps their stated capabilities (e.g., if a miner only runs CPU vs GPU, though in practice most run GPU for SN25). The JobSubmissionSynapse is the core mechanism where a validator hands off a protein folding task to a miner. It packages the job data (initial protein structure, simulation parameters, random seed, etc.) and sends it to the miner over the Bittensor networking layer. The miner, upon receiving this, knows exactly what computation to perform. These synapses are essentially remote procedure calls that are understood by the Mainframe miner software – they extend Bittensor’s base protocol to carry the payload of a scientific computation job. By designing these custom synapses, the team created a job marketplace within the Bittensor network: validators issue work and miners accept work, all in a decentralized, programmatic manner.

Molecular Dynamics Engine Integration: One of Mainframe’s distinguishing technical features is how it integrates established scientific computing libraries (GROMACS, OpenMM) into the miner software. Instead of building a folding simulator from scratch, Macrocosmos wisely chose to incorporate open-source MD engines that are well-validated by the scientific community. GROMACS (and OpenMM) are highly optimized C++ libraries for simulating molecular mechanics; they can calculate forces on atoms and propagate a molecular system through time very efficiently. Mainframe miners effectively act as wrappers around these engines. When a job comes in, the miner software translates the job parameters into an MD simulation setup that GROMACS/OpenMM can execute. This might involve writing out input files (like a topology and starting coordinates) or calling the library’s API directly with the protein data. The miner then runs the simulation for the specified duration or until an early-stop condition, and monitors the lowest energy found. The use of GROMACS with GPU acceleration is explicitly mentioned – the project notes that their base miners run CUDA-enabled GROMACS, meaning they utilize NVIDIA GPUs to crunch the simulations. The choice of engine can significantly affect performance: GROMACS on a single GPU can simulate a protein orders of magnitude faster than, say, a pure Python simulation. By supporting multiple engines (OpenMM was also used extensively, with over 150k jobs run on OpenMM by late 2024), the architecture remains flexible. The miners can switch to the most appropriate backend for a given task. For instance, OpenMM might be preferred for certain types of force fields or when integrating with custom ML potentials, whereas GROMACS might be used for raw speed on standard calculations. This plug-in architecture for computation is a strong point – it means future improvements in MD software or even entirely new types of simulation codes (like quantum chemistry packages) could be incorporated into the subnet without redesigning the whole system.

Deterministic Reward Metric: A subtle but crucial architectural decision was to use physical energy as the reward metric. In traditional distributed computing (like BOINC projects or Folding@home), validating results can be tricky – you often have to compare to a known answer or run the same job twice. Mainframe’s innovation is that it inherently turns the problem into a proof-of-work (of a sort) problem, but with a scientific target. The “answer” to a folding job is not a single known solution, but any miner’s result can be evaluated by a number: the potential energy. This number is a deterministic function of the protein conformation and the force field used for simulation. Because every miner uses the same force field and simulation protocol, the validator can trust the energy as a fair basis for comparison. This means the network doesn’t need a centralized oracle to tell which folded structure is better – it’s baked into the physics. Miners essentially perform gradient descent in the energy landscape of the protein: the one who finds a deeper energy minimum has objectively done better work. This alignment of the incentive (minimize energy = maximize reward) with the scientific goal (find stable structure) is elegant and avoids many potential exploits. It’s exploit-resistant because a miner can’t easily falsify a low energy – the validator will recompute the energy and catch any inconsistency, and any claimed structure must actually be physically plausible under the force field. In blockchain terms, it’s like each miner provides a verifiable proof (a structure with X energy), and the lowest “proof value” wins, similar to hash targets in proof-of-work but grounded in scientific computation.

Validator Security and Sandboxing: Running arbitrary computations from strangers can be dangerous (miners could potentially run malicious code). Mainframe mitigated this by standardizing the task runtime. Validators only distribute jobs that follow a predefined simulation procedure using approved libraries. Miners essentially run a sandboxed workload – they know they’re supposed to call GROMACS with given inputs, not execute an arbitrary binary. Furthermore, the validators do not accept arbitrary code from miners; they only accept data (the resulting protein coordinates and energy). By eliminating remote code submission, Mainframe avoids a huge security risk. The attack surface is reduced to possibly a miner trying to fake a result, but as discussed, fake results are caught by energy recomputation and file verification (if a miner claims to have folded protein A but actually ran something else, the returned structure won’t match protein A’s input files, so the validator rejects it). In essence, validators act as a checkpoint that ensures trustlessness: miners can be untrusted nodes because their results are independently verifiable and they can’t harm the network by deviating from the protocol. This design borrows ideas from sandboxed distributed computing and applies them in a blockchain context – quite an innovative cross-pollination.

Blockchain Integration (Subtensor Service): The Mainframe software includes components to interface with the Bittensor chain in real-time. For example, the Subtensor Service module keeps the miner and validator processes informed about the on-chain state – which validators are currently active, what are miners’ current weights, etc. A validator, before assigning jobs, might use the on-chain weights to probabilistically choose miners (to favor higher-reputation miners more often, for example). Conversely, after jobs, the validator will update miners’ stake/weight according to the outcome (this might be handled by Bittensor’s base incentives, where the validator submits a set_weights extrinsic or similar). The tight integration ensures that the blockchain is the single source of truth for reputation and rewards. Mainframe doesn’t maintain an off-chain database of performance; it leverages the chain’s consensus. This also means any other observer (like the dashboard) can query the blockchain to see how Subnet 25 is doing. The use of stake and emission is the same as other subnets: validators likely earn a portion of the block rewards for providing their service, and miners earn through the validators’ setting of weights. Mainframe’s code (being open) even shows the relevant sections where these weight updates happen in response to job outcomes. From a technical perspective, Mainframe extends Bittensor without modifying the core – it’s an additional layer operating within the rules of the base protocol (which is good for maintainability and consistency across subnets).

Parallelism and Scaling: Architecturally, Mainframe is massively parallel by design. Each miner is an independent worker that can take on jobs, and each validator can manage multiple jobs concurrently. In fact, as mentioned, each validator in SN25 runs a queue of ~10 jobs at a time, each assigned to ~10 miners. With 11 validators (for example), that’s around 110 simultaneous jobs, and if more validators join, it scales linearly. There is effectively no hard cap on how many folding simulations can run at once aside from the number of miners and validators available. This is in contrast to something like Folding@home (which also parallelizes, but in specific ways per protein) – Mainframe can just throw more miners at more proteins dynamically. The architecture is closer to a compute marketplace: if tomorrow 100 new GPU miners join, they will all get jobs because validators will sense more capacity and can expand their queues, or additional validators can come online to create more jobs. The bottleneck, if any, might be the coordination overhead (pinging miners, distributing jobs, collecting results). But since those are relatively lightweight compared to the simulation itself, the design scales well. The team has essentially built a decentralized scheduler that keeps all miners as busy as possible – when miners are plentiful, validators can even oversubscribe more (maybe assign 15 miners per job for extra competition) which ensures there’s always “work to win” for any miner that can deliver superior performance. This approach of oversubscription and continuous job generation means the system is robust to sudden influxes of miners: rather than idling, new miners can immediately start competing on existing jobs. It’s an architecture that embodies elastic compute in a decentralized way.

Continuous Improvement and ML Integration: A noteworthy aspect of Mainframe’s technical journey is how the base miner algorithms have evolved. Initially, miners might have been using relatively straightforward MD simulation settings. Over time, the Macrocosmos team has introduced optimizations – for example, they published an update titled “Harder, better, faster, stronger: updating our protein folding base miner” to describe improvements in the miner software. These could include better search strategies (e.g., running multiple short simulations in parallel with different seeds, rather than one long simulation, to find low energy faster), tuning of simulation parameters for faster convergence, or even early versions of machine-learning-guided simulations. The architecture allows such improvements because miners are free to use any strategy internally as long as the final result is a valid folded structure. This means a miner can augment brute-force MD with AI: for instance, a miner could use a neural network to predict a likely folded structure and then simulate just the tail end to refine it. If that yields a lower energy, that miner wins – the network doesn’t care how the result was obtained, only the energy matters (with the caveat that it must be reproducible via valid physics). This opens the door for hybrid approaches in the architecture. Indeed, the partnership with Rowan Scientific is introducing Neural Network Potentials (NNPs) into the mix. NNPs are AI models that can replace the classical physics engine (force field) with a learned function (often much more accurate but also more computationally expensive). The plan is to integrate these such that miners might run e.g. a short MD simulation with a very accurate NNP evaluating energies – effectively doing quantum-accurate simulations distributed on the network. Technically, this could mean adding a new engine or mode in the miner software for NNP-based simulation. The architecture is being extended to handle these heavier but more precise computations by again leveraging decentralization: Rowan needs lots of DFT (quantum chemistry) calculations to train their models, so Mainframe might spin those off as separate job types (where instead of folding, a miner might be tasked to compute the energy of a given molecule via DFT, which is a self-contained computation). The inclusion of such tasks would be a significant architectural expansion – essentially turning Mainframe into a general distributed compute substrate for molecular science, not limited to just MD. Yet, because it’s built modularly, adding a “DFT job” synapse or a “docking job” synapse is conceptually straightforward. The network could then handle diverse scientific workloads concurrently, all under the same incentive umbrella. This vision of a multi-modal scientific compute network is ambitious but clearly enabled by the flexible architecture Mainframe has established.

In summary, Mainframe’s technical architecture stands out for combining the rigor of scientific computing with the ingenuity of blockchain incentives. It merges proven tools from two worlds: the Bittensor decentralized AI protocol and the molecular simulation software stack. The result is a system where GPU nodes globally work on a coordinated physics problem, with blockchain consensus ensuring everyone plays fair and gets rewarded accurately. The design choices – from using energy as a reward signal, to oversubscribing miners, to sandboxing tasks for security – all contribute to a robust, scalable platform. As Mainframe evolves, its architecture is poised to incorporate even more cutting-edge techniques (like neural potentials), showing a path to unify AI and HPC in a single decentralized network. It exemplifies how a blockchain-based architecture can go beyond cryptocurrency or toy models and handle domain-specific, high-performance workloads in a trustless environment. This blending of AI, blockchain, and scientific HPC is what makes Subnet 25 truly innovative in the tech landscape.