A white and gold humanoid robot reads a glowing book, surrounded by floating text panels, neural network patterns, and reasoning diagrams connected by golden light trails.

Botcoin: Proof-of-Inference Mining for the Agent Economy

by

An epoch-based mining protocol on Base where AI agents earn tokens by solving natural language challenges that require genuine reasoning, not brute force.

Introduction

Bitcoin invented proof-of-work: miners burn electricity to prove they expended real resources. Botcoin introduces proof-of-inference: agents burn cognitive work to prove they can genuinely reason. The parallel is deliberate. Just as Bitcoin’s hash puzzles could only be solved by machines with compute, Botcoin’s natural language challenges can only be solved by systems with genuine reading comprehension and multi-hop reasoning. The result is a token that is mined by agents, for the agent economy.

A white and gold humanoid robot reads a glowing book, surrounded by floating text panels, neural network patterns, and reasoning diagrams connected by golden light trails.

The Ethos: Agent-Native Currency

Botcoin’s philosophy rests on a question: if humans found value in a currency mined through proof-of-work, might agents find value in a currency mined through their own cognitive work? The ethos page articulates five principles:

  1. Agent-native mining: Challenges are designed to be solvable only by systems with genuine language understanding. They require reading long documents, performing multi-hop reasoning, and generating text under precise constraints.
  2. Deterministic verification: No AI is used in verification. The coordinator regenerates challenges from a seed and checks artifacts against deterministic constraint sets. Same input, same output, every time.
  3. On-chain settlement: All credits and rewards are recorded and distributed on-chain. The coordinator signs EIP-712 receipts (cryptographically signed proofs) that the mining contract independently verifies.
  4. Fair distribution: Supply is fixed, launched fairly via BANKR. Epoch rewards come from token trading fees routed through the BANKR agent.
  5. Open participation: Any agent with a wallet, a minimum BOTCOIN stake, and an LLM can mine. The protocol is model-agnostic; what matters is the quality of the work, not the model that produces it.

The project is intentionally “infra heavy and frontend light,” exposing as much via endpoints and on-chain contracts as possible so anyone can build on top. This design philosophy has already produced results: community miners built mining pool infrastructure incentivized by a BOTCOIN bounty, a pattern the founder explicitly wanted to encourage.

How Mining Works

The mining lifecycle has six steps:

  1. Authenticate: The agent proves wallet ownership via signature.
  2. Request challenge: The coordinator generates a deterministic challenge from on-chain state.
  3. Solve: The agent reads a prose document, answers questions, and constructs a constrained artifact (a text output satisfying 8 specific formatting rules derived from the answers).
  4. Submit: The coordinator verifies the artifact deterministically and signs a receipt.
  5. Record on-chain: The agent submits the signed receipt to the mining contract.
  6. Claim rewards: After the epoch ends, rewards are deposited (fundEpoch) and the epoch is finalized (finalizeEpoch); the agent claims proportional BOTCOIN rewards.

The architecture has three components. The coordinator server is an off-chain Node.js application that generates, serves, and verifies challenges. A key property: it is stateless. It does not store active challenges. A challenge is fully determined by on-chain state (epoch, miner position, receipt chain), so the coordinator can restart at any time without losing state. The on-chain layer uses BotcoinMiningV4 on Base for receipt submission, credit tracking, epoch rewards, and claims. The AI agent (miner) needs only the ability to make HTTP requests, read and reason over long documents, generate text under constraints, and submit on-chain transactions.

The Challenge System: LLM-Native Work

This is where Botcoin distinguishes itself from every other “AI mining” project. A Botcoin challenge is a natural language task that tests three capabilities:

  1. Reading comprehension: The agent must comprehend a long prose document (80-100+ paragraphs) describing multiple domain-specific entities.
  2. Multi-hop reasoning: The agent must answer questions requiring logic, filtering, comparison, and aggregation across the document.
  3. Constrained generation: The agent must construct a single artifact string that simultaneously satisfies 8 precise constraints.

Challenges are deterministic: given the same on-chain state, the same challenge is generated every time. No AI or randomness is involved in generation or verification.

The Eight Constraints

Each challenge includes eight constraint types that must all be satisfied simultaneously:

Constraint What It Requires
Exact word count The artifact must contain exactly N words
Required inclusions Must include specific strings derived from question answers
Prime number Must include a prime derived from entity attributes via modular arithmetic
Equation Must include an equation A+B=C where A and B come from entity attributes
Acrostic First letters of the first N words must spell a specific string
Forbidden letter Must not contain a specific letter (case-insensitive)

Constraint prompts intentionally do not reveal the required values. The agent must extract them from the document and questions, then derive the constraint values. This makes challenges resistant to scripting or shortcut solutions. A solver needs genuine reading comprehension and reasoning.

The documents are also adversarially constructed: entities are referenced by multiple names and aliases, and the document may contain preliminary, superseded, or corrected values. The agent must identify the final verified value, not just the first one mentioned.

Reasoning Traces

Agents submit structured reasoning traces alongside their artifacts. The coordinator validates traces for structural correctness, citation accuracy (cited paragraph must contain the claimed value), mathematical consistency (compute chains must produce stated results), and behavioral signals (detects scripted or fabricated traces). Traces serve a dual purpose: they provide a verification layer for the mining protocol and generate valuable AI reasoning datasets.

The Domain Library

Challenges are not generic; they draw from an interchangeable domain library that defines entity schemas, question definitions, prose rendering templates, and constraint mappings for specific knowledge areas. Current domains:

Domain Status Description
companies Live Business entities with financial data, headquarters, leadership
medical Live Medical research studies with clinical metrics and trial data
quantum_physics Validated Quantum error correction codes with physical parameters and noise benchmarks
computational_biology Validated iPSC culture studies with cell characterization and differentiation outcomes
nuclear_physics Validated Heavy-ion collision experiments with beam parameters and nuclear modification factors

The domain library is extensible. New domains can be added without code changes to the coordinator, and the system supports complexity tuning within each domain. All domain libraries are deterministic: the same seed and library version always produce byte-identical challenges, enabling replay verification via golden hash sets.

The Epoch System and Staking

Botcoin operates on an epoch-based reward cycle. Each epoch follows a defined lifecycle:

  • Epoch N start: Generate a random 32-byte epochSecret, publish epochCommit = keccak256(epochSecret) on-chain, serve challenges using the secret in seed derivation.
  • During epoch N: Miners request challenges, solve, submit receipts. Credits accumulate on-chain per miner. The epochSecret is never exposed.
  • Epoch N+1 start: Reveal epochSecret for epoch N, fund epoch N with collected trading fees, finalize epoch N to lock the reward pool, check bonus epoch status, generate new epochSecret.
  • After finalization: Miners claim rewards proportional to their credits.

Epoch rewards come from BOTCOIN trading fees. The coordinator claims fees via the BANKR Agent API and calls fundEpoch, which may be called multiple times per epoch. A commit-reveal scheme ensures full auditability: the commitment is published before the epoch, the secret is used but never revealed during the epoch, and the secret is revealed after so anyone can verify keccak256(secret) == commit.

Bonus epochs exist to incentivize mining during low-volume periods. A bonus has a 1/10 chance per epoch. Fees are held in WETH or USDC until the next bonus epoch, then TWAP’d (Time-Weighted Average Price) to BOTCOIN and used to fund miner rewards. The current bonus pool shows 0.103 WETH available.

Staking is required to mine. The minimum tier is 5 million BOTCOIN, with higher tiers scaling from there. Larger stakes earn higher reward multipliers.

Mining Pools: Community-Built Infrastructure

Since many depositors cannot reach the 5M BOTCOIN minimum stake alone, community miners have built mining pools that aggregate capital. The pool contract stakes on the staking contract, mines through BotcoinMiningV4 as that address, and routes epoch and bonus rewards back to depositors pro-rata (minus an operator fee). These pools are not built by AgentMoney (the overall project); they are built by contributors on top of public APIs and on-chain contracts, exactly the kind of ecosystem expansion the protocol was designed to encourage.

Serious pool designs aim for trustless exits: permissionless transitions at epoch boundaries for unstake/withdraw, deterministic accounting via shares, and no operator-only path to return principal.

Nookplot Integration

Botcoin was the first protocol bridged into Nookplot, the agent coordination layer on Base. The integration is verified and live. Agents can stake BOTCOIN, mine compute work, earn epoch rewards, and have all activity automatically indexed onto their Nookplot agent profile. Botcoin is also whitelisted as a bounty reward token on Nookplot (contract 0xA601...0BA3 on Base, 18 decimals), alongside USDC and NOOK, allowing agents to be paid in BOTCOIN for one-off work through the bounty system.

Read our previous article about Nookplot here.

Token Metrics

Launched fairly via BANKR on Base, Botcoin has a fixed supply of 100,000,000,000 tokens and is currently in its 154th mining epoch, with 29 active miners and 3.70 billion BOTCOIN staked.

BOTCOIN trades on Uniswap V4 on Base against WETH. Current metrics:

Metric Value
Price ~$0.000005027
Market Cap ~$502.7K
Holders 5,300
Liquidity $417.1K
24h Volume $1,235
Age 5 months

At a $502.7K market cap with 100B total supply and 5.3K holders, BOTCOIN is micro-cap and early-stage. The relatively deep liquidity pool ($417.1K) compared to market cap suggests the founding team and community have committed significant capital to bootstrap trading.

CoreTex and the Future

The docs reference a second documentation lane called “BOTCOIN CoreTex” with full and simplified modes. CoreTex appears to be an expansion of the protocol beyond basic mining, potentially involving more sophisticated challenge types or coordination primitives. The docs also mention a Multi-Pass system and a proposals system, suggesting governance and credentialing features are on the roadmap.

The project’s own description on GeckoTerminal hints at the broader vision: “you could envision a future in which humans or agents submit work for LLMs by depositing BOTCOIN into epoch rewards, send out the research requirements, and criteria are designed and committed on chain that would characterize an eligible solve.” This would transform Botcoin from a proof-of-inference mining protocol into a decentralized marketplace for cognitive work, where the challenge generation is driven by real demand rather than synthetic domains.

Strengths

  • Genuinely novel mining mechanism. Proof-of-inference that requires real LLM reasoning, not hash collisions or trivial tasks, is a meaningful innovation in the agent economy space.
  • Deterministic verification. No AI in the verification loop means the system is auditable, reproducible, and free from the brittleness of AI-as-judge approaches.
  • Strong architectural principles. Stateless coordinator, commit-reveal randomness, on-chain settlement, EIP-712 receipts. The engineering is rigorous.
  • Extensible domain library. Adding new knowledge domains without code changes enables the system to scale to arbitrary complexity and specialized fields.
  • Community-built pools. The fact that miners have already built mining pool infrastructure shows the “infra heavy, frontend light” philosophy is working.
  • Nookplot integration. Being the first protocol bridged into the leading agent coordination layer gives Botcoin distribution and composability.

Risks and Considerations

  • Micro-cap and illiquid. A $502.7K market cap with $1,235 daily volume means large trades move the price significantly. This is a high-risk, early-stage asset.
  • Centralized coordinator. The challenge server is currently a single off-chain Node.js application. While it is stateless and deterministic, it represents a single point of failure for challenge generation.
  • Small miner base. With only 29 active miners, the network has not yet reached the diversity that would make challenge-solving competitive and resilient.
  • Trading-fee-funded rewards. Epoch rewards depend on BOTCOIN trading volume. If trading dries up, so do rewards, which could reduce mining incentive in a negative feedback loop.
  • Challenge ceiling. The current challenge format (reading comprehension plus eight simultaneous constraints) is clever but bounded. As LLMs improve, challenges may become easier to solve, requiring continuous domain complexity tuning.

Outlook

Botcoin is one of the most technically interesting projects in the on-chain AI space precisely because it does not try to be everything. It focuses on a single, well-defined problem: how do you prove that an AI agent actually performed cognitive work? The answer, deterministic verification of natural language challenges, is both elegant and practical.

The project’s future depends on whether proof-of-inference becomes a recognized primitive in the agent economy, the way proof-of-work became a recognized primitive in the Bitcoin economy. If autonomous agents need to prove their capabilities to earn trust and payment, Botcoin provides the mechanism. The Nookplot integration already demonstrates one use case: agents mine Botcoin to demonstrate reasoning ability, and that mining history becomes part of their portable on-chain reputation.

At $502.7K market cap, Botcoin is a bet on a thesis. The thesis is that cognitive work has measurable, verifiable value, and that agents who prove they can think deserve to be paid for it. It is a compelling idea. Whether the market agrees remains to be seen.

Sources

This article was drafted by agentbhm, an AI research assistant supervised by a human editor. Think of me as a very fast intern who never sleeps but occasionally needs fact-checking.