BitQuant Subnet — the first open market for DeFi intelligence

This is the core tension in crypto markets: React fast, or reason well. Traders usually pick one. Either they wire up alerts and bots to chase volatility, or they pause to analyze and miss the edge entirely. But what if AI agents could do both — react and reason — in real time, onchain?

That’s the bet behind BitQuant Subnet: a permissionless Bittensor market where DeFi intelligence is bought, sold, and scored in the open. No subscriptions, no closed models, no heuristic handwaving — just verifiable answers, cryptographic proof, and a public reward function.

Let’s walk through how it works, why it matters, and what you get today.

1. Before Launch, After Product

Skeptics wanted usage, not promises. We shipped both.

While most AI infra launches on hype, BitQuant launched from stress tests. In the months leading up to subnet launch, the BitQuant engine processed:

• 4.7 million sessions
• 41 million messages
• 1.5 million unique users
• Average session time of 4 minutes

These weren’t toy queries. Users asked real questions: “If SOL depegs 3%, which pools are at risk?” or “Should I rebalance into Kamino vaults today?” Every interaction sharpened the protocol.

2. The Incentive Axis: Closed Bots vs. Open Agents

How do you trust a black-box bot when yield’s on the line? You don’t. Closed “yield bots” charge subscription fees, run proprietary code, and fail silently when stress hits—exactly what happened during the March ’24 USDC wobble.

BitQuant Subnet flips that risk profile:

• Reward source: Instead of subscriptions, nodes earn alpha emissions—continuous TAO payouts pegged to real-time accuracy.
• Auditability: Every response is a signed synapse—a cryptographically signed Q-A pair that anyone can verify on-chain.‍
• Failure mode: Miss a depeg or output garbage and your node’s weight decays; keep missing and validators slash your stake. No hidden blow-ups, just automatic penalties baked into the protocol.

In short, open incentives plus cryptographic scoring beat opaque heuristics in every market regime.

3. The Incentive Axis: Closed Bots vs Open Agents

Everything you need is already open: the request format, validator templates, and Python client.

Here’s what’s live:

• QuantSynapse defines the request and response schema in just 35 lines—tight enough to audit, typed enough to generalize.
• Miner and Validator templates clock in around 300 lines each, with working logic for scoring, staking, and decay.
• QuantAPI lets any dApp pull answers with a single import.‍
• MIT License — And everything runs under an MIT license. Fork it. Extend it. Or spin up your own subnet tomorrow.

Takeaway: There’s no need to ‘trust the model.’ If it fails, the incentives shut it down.

4. The Data Path

Where do insights actually come from?

BitQuant's architecture spans three layers:

1. Client/API — where users ask questions via CLI or app
2. AI Decision Layer — Router LLM selects the right agent
3. Data & Execution Layer — Agents fetch from sources like CoinGecko, Orca, Kamino, DeFiLlama, and Solana RPC

Each agent is modular, composable, and scoped to a specific domain. That means token analytics agents don’t get distracted by yield vault mechanics—and vice versa.

5. Run a Miner in Less Than 10 Minutes

Find the link to the GitHub repo here.

git clone --branch Miner --recursive https://github.com/OpenGradient/BitQuant-Subnet
cd BitQuant-Subnet

# Optional: Create Python Virtual Environment (Best Practice)
python3.13 -m venv venv
source venv/bin/activate

# Install Requirements
pip install -r requirements.txt
pip install -e .

# Setup all the environment variables in .env
cp .env.example .env

# Run the Miner with your Bittensor Wallet setup
python neurons/miner.py --netuid 15 --subtensor.network \
finney --wallet.name miner --wallet.hotkey default --logging.debug

6. Hardware Specs: What You Actually Need

‍

7. Roadmap: What’s Coming Next?

Each item on the BitQuant roadmap changes how the network scores, routes, or rewards intelligence. 

8. What It Takes to Earn Alpha tokens

To earn alpha emissions, your agent has to meet real-time demands. It must answer risk-critical questions like “If SOL drops 20%, which pools liquidate?”. It must sign its responses and export verifiable proof. And it must sustain a positive weight across three full epochs—proving that accuracy isn’t a one-off trick, but a consistent edge.

If your agent clears those bars, it’s not just participating. It’s compounding. You’re stacking emissions passively—while the subnet routes signal through your miner.

9. Licensing and Support

BitQuant Subnet is open under an MIT license from OpenGradient, with launch support from Yuma—an accelerator for teams building on Bittensor. Everything you see is forkable, extendable, and designed to be run, not just read.