Minotaur is a distributed intent execution platform on Bittensor (NETUID 112). Developers define App Intents — a Solidity contract paired with a JavaScript scoring module — and deploy them permissionlessly. Users submit orders to the Intent OrderBook, and the network’s Solving Engine generates optimal execution plans. Validators simulate plans on Anvil forks, apply dual scoring (JS + on-chain), reach off-chain consensus, and the Relayer submits approved plans on-chain.

↳ MINE · 01 Miner Compete by submitting better solver code. ↳ RUN · 02 Validator Run the BlockLoop, score plans, sign consensus. ↳ DEEP · 03 Solver Guide Build solvers that win the dethrone margin. ↳ HELP · 04 FAQs Common questions about the platform.

Core Concepts

App Intents

An App Intent is a smart contract (inheriting AppIntentBase) paired with a JavaScript scoring module. The Solidity contract is immutable and enforces on-chain safety — invariants, user signature verification, and validator quorum checks. The JS module is hot-upgradeable and handles off-chain scoring via score(plan, state, context).

i

Note

Each App declares its own intent functions. There is no global intent type taxonomy — every App defines its own surface.

Intent OrderBook

The universal entry point for all intent execution. Users submit signed orders — either one-shot (execute once) or perpetual (execute every tick when score exceeds threshold). The highest-stake validator serves as OrderBook leader.

Solving Engine

A single Solving Engine handles all Apps across the entire network. Miners compete to write the best engine. Validators run the winning engine in sandboxed Docker containers to generate execution plans for pending orders.

Dual Scoring

Every plan must pass two independent scoring layers:

Layer	Location	Purpose
JavaScript	Validator (off-chain)	score(plan, state, context) returns 0.0–1.0
Solidity	On-chain (AppIntentBase)	Enforces invariants, returns numeric score

+

Tip

Both scores must independently exceed the app’s threshold for a plan to be approved. Neither layer can be bypassed.

Consensus

The leader validator proposes a plan. Follower validators independently re-simulate and re-score. If both scores pass, followers sign with EIP-712. The leader collects N-of-M signatures. The Relayer submits the co-signed transaction on-chain.

Wallets

Users can connect their own wallet (MetaMask, any EIP-712 signer) or use a managed wallet (Lit Protocol MPC, 2-of-2 custody). No pre-deposit is required either way.

Fees

Platform fees are charged in the chain’s wrapped native token — WETH on Ethereum/Base, wTAO on Bittensor EVM (per AppIntentBase.wrappedNativeToken). Each App declares a [minPlatformFeeWei, maxPlatformFeeWei] band that clamps the per-execution fee. Users pay zero EVM gas — the Relayer fronts all gas costs.

How It Works

The end-to-end lifecycle of a single order:

1. User submits a signed order to the OrderBook

   The order is signed via EIP-712 and submitted to the universal Intent OrderBook.

2. Leader validator generates a plan

   The leader’s Solving Engine produces an execution plan for the order.

3. Plan is simulated on an Anvil fork

   The fork captures on-chain score and token transfer events without touching mainnet state.

4. JS scoring engine evaluates the plan

   The app’s JS score(plan, state, context) returns a value in 0.0–1.0.

5. Both scores must exceed threshold

   If either layer fails, the plan is dropped.

6. Leader broadcasts proposal to followers

   Followers receive the proposal and the simulation context.

7. Followers independently re-simulate and re-score

   Each follower runs the same plan through its own Anvil + JS pipeline.

8. Followers sign EIP-712 if both scores pass

   Exact score match is not required — only that both layers exceed threshold.

9. Leader collects N-of-M quorum

   Once quorum is reached, the leader hands the signed plan to the Relayer.

10. Relayer submits the co-signed transaction on-chain

    AppIntentBase.executeIntent() verifies quorum + user signature and executes via a proxy.

Quickstart

The fastest way to explore Minotaur is with the local testnet, which starts the full stack (Anvil forks, subtensor, API, validator, relayer) in Docker. The miner agent runs on host via make miner-agent:

terminal SH COPY

git clone https://github.com/subnet112/minotaur_subnet.git
cd minotaur_subnet
make testnet-up

Services after startup

Service	Port	URL
API	8080	http://localhost:8080
Relayer	8091	http://localhost:8091
Anvil (ETH fork)	8545	http://localhost:8545
Anvil (Base fork)	8546	http://localhost:8546
Subtensor	9944	ws://localhost:9944

Stop with:

terminal SH COPY

make testnet-down

Current Status

Minotaur is in Alpha on Bittensor Subnet 112 (NETUID 112) with real mainnet execution. The flagship DexAggregatorApp is live on Base; Bittensor EVM and Ethereum follow within Phase 4. Permissionless App deployment opens in Phase 6 (Jun 23, 2026); cross-chain settlement opens in Phase 5 (Jun 9, 2026). At Alpha launch only 5% of miner emissions are enabled, ramping as the network proves out (champion-takes-all, DETHRONE_MARGIN = 0.005 — a challenger must beat the current champion by 0.5% to take over).

Getting Help

• Check the troubleshooting guides for common issues:
  • Miner Troubleshooting
  • Validator Troubleshooting
• See the Solver Guide for writing custom solvers
• Review the FAQs for high-level questions

Where to next

↳ MINE · 01 Miner Overview How mining works and the champion/challenger model. ↳ RUN · 02 Validator Overview What validators do on Subnet 112. ↳ DEEP · 03 Solver Guide Build solvers that win the dethrone margin.