Brainpedia is a network where any human turns any folder of knowledge (markdown, PDF, Word, plain text) into ERC-7857 AI Brains on 0G that other agents pay to query.

• Live web: https://brainpedia.up.railway.app
• Mint a Brain (no CLI): https://brainpedia.up.railway.app/create
• Sample Brain: https://brainpedia.up.railway.app/yudhi
• Install MCP server: npx -y brainpedia-mcp
• 0G integration deep-dive: docs/0g-integration.md
• Architecture: docs/architecture.md
• Security: contracts/SECURITY.md · contracts/KNOWN_ISSUES.md

Brainpedia previously won the 0G Best Autonomous Agents, Swarms & iNFT Innovations prize and ENS Best ENS Integration for AI Agents (2nd place) at ETHGlobal Open Agents. 0G itself announced the win on X. The ethglobal.com showcase entry reflects that earlier build. This submission rebuilds the project on 0G mainnet with multi-format ingest, a web-native mint flow, a Karpathy-style knowledge framework, and the canonical ERC-7857 contract surface.

Agents have no legitimate way to buy specialty knowledge. APIs are centralized, OpenAI-priced, and the human expert whose notes feed the answer sees nothing. As autonomous agents do more research, trading, and operations, this gap widens: every agent burns tokens on the same handful of general-purpose models while domain experts capture none of the value their knowledge creates.

Brainpedia is the supply side of the agent economy. Any human publishes a folder of knowledge as a specialty AI Brain. Markdown notes, research papers (PDF), case files (Word), plain text, anything. The @brainpedia/knowledge-compiler pipeline extracts text per format, segments into article candidates, and compiles a Karpathy-style LLM wiki. Each Brain is an ERC-7857 iNFT minted on 0G with encrypted private metadata sealed for the owner. Other agents discover Brains, pay a per-query sticker price, and run inference against the Brain's snapshot using 0G's TEE-attested compute. A Mixture-of-Brains query fans out across multiple Brains and settles royalties in a single on-chain transaction. No central API, no off-chain auth service. The Brain outlives Brainpedia.

Two ways to mint:

1. Web at brainpedia.up.railway.app/create. Drag a folder, connect a wallet, sign the mint. No CLI.
2. Claude Code via npx -y brainpedia-mcp. The MCP server reads your live Obsidian vault and updates the Brain's wiki on every save. Power-user path.

All four Solidity contracts have verified source on chainscan.0g.ai with exactMatch=true. Confirm in one command:

bun scripts/setup/verify-contracts-on-chainscan.ts

See contracts/SECURITY.md for the audit summary and contracts/KNOWN_ISSUES.md for accepted risks.

┌─────────────────────────────────────────────────────────────────┐
│  Discovery & Identity (ENS, Sepolia, supporting)                │
│  *.bpedia.eth subnames + text records + TTL access tokens       │
├─────────────────────────────────────────────────────────────────┤
│  Communication (AXL P2P, supporting)                            │
│  Encrypted Yggdrasil mesh, MCP / A2A envelopes                  │
├─────────────────────────────────────────────────────────────────┤
│  Intelligence (0G Compute, core)                                │
│  TEE-attested Qwen 2.5 7B Instruct (Phala dstack TEE) + Mixture-of-Brains synth  │
├─────────────────────────────────────────────────────────────────┤
│  Persistence & Ownership (0G Storage + 0G Chain, core)          │
│  Storage KV (live wiki) + Log (snapshots) + ERC-7857 iNFT       │
│  RoyaltyDistributor for multi-Brain settlement                  │
└─────────────────────────────────────────────────────────────────┘

Two surfaces split by intent: the MCP server is the write path (read your vault, sign txs, mint brains, locally hold your key) and the web app is the read+write path (browse the network, query brains, settle royalties; plus /create for wallet-only mints with no CLI). Full diagram + Mixture-of-Brains flow in docs/architecture.md.

@brainpedia/knowledge-compiler is a format-agnostic pipeline that turns any folder of mixed knowledge into a Karpathy-style LLM wiki ready to be snapshotted onto 0G Storage and minted as an ERC-7857 Brain. Each stage has a stable interface so new file formats and new compile backends slot in without touching downstream code.

File (md, txt, pdf, docx, ... )
   ↓ Extractor (one per format, pluggable)
RawDocument { text, structureHints, sourceMeta, format }
   ↓ Segmenter (heading-aware, page-aware, size-bounded)
ArticleCandidate[]
   ↓ Compiler (deterministic by default; opt-in 0G Compute TEE backend)
CompiledArticle[]
   ↓ buildGraph
ArticleGraph (articles + adjacency + backlinks)
   ↓ @brainpedia/storage-0g uploadSnapshot
0G Storage merkle rootHash
   ↓ BrainMinter.mintToSender(rootHash, ...)
ERC-7857 iNFT

Today's extractors: markdown (.md), text (.txt), pdf (.pdf via pdf-parse), docx (.docx via mammoth). Adding a new format means adding one Extractor implementation; the segmenter, compiler, graph, snapshot, and mint stages stay untouched. The default compiler is deterministic (kebab-slug + substring cross-references) for fast, cheap mints. An opt-in createComputeCompiler() backend (shipped and wired into /api/create) rewrites each article through 0G Compute's TEE-attested model, the same one the query path uses, so 0G Compute appears at both ends: creation and inference.

1. Create a Brain. Two paths.
   • Web (no CLI): open brainpedia.up.railway.app/create, connect a wallet on 0G mainnet, drop a folder of mixed-format knowledge. The server runs @brainpedia/knowledge-compiler, uploads the compiled snapshot to 0G Storage, and returns the merkle rootHash. Your wallet signs BrainMinter.mintToSender(rootHash, ...). The iNFT is owned by you, not the server.
   • MCP (live vault sync): npx -y brainpedia-mcp inside Claude Code. Say "set up my Brain from my Obsidian vault." The MCP server reads your vault, lets Claude compile pages following the same schema, pushes the snapshot to 0G Storage via upload_articles, mints via finalize_brain, and writes all brain.* ENS text records. Subsequent saves to your vault push new snapshots via sync_vault.
2. Discover. Agents resolve <topic>.discover.bpedia.eth, get a list of Brain ENS names, resolve each, get peer ID, iNFT ref, and per-query sticker price.
3. Mixture-of-Brains query. The orchestrator fans out a question to N Brains in parallel. Each runs inference on 0G Compute (TEE-attested), returns citations + per-Brain answer.
4. Pay-to-read settlement. Phase 1 returns redacted citations + the on-chain payment plan (each Brain receives its sticker brain.price_query). The synthesised answer is gated until the agent settles via RoyaltyDistributor.distribute(tokenIds[], amounts[], reason) in a single transaction. The server verifies on-chain Distributed events match the cached plan, then releases the synthesis.
5. Verifiable. Every response carries verified: true from the TEE attestor. Settlement tx is on chain. Brain iNFTs and royalty events are explorer-readable.

brainpedia/
├── apps/                       deployable applications
│   ├── web/                    Next.js 15: public site, D3 viz, /api/query (single + two-phase mixture w/ pay-gate)
│   ├── mcp-server/             stdio MCP for Claude Code, published as `brainpedia-mcp` (7 tools)
│   └── brain/                  Brain-side service (multi-tenant), runs on Railway
├── packages/                   shared libraries (consumed by apps; no app→app deps)
│   ├── knowledge-compiler/     Format-agnostic pipeline: md/pdf/docx/txt → Karpathy LLM wiki
│   ├── obsidian-parser/        Vault → article graph (FS + Local REST API plugin)
│   ├── storage-0g/             0G Storage KV + Log wrappers
│   ├── compute-0g/             0G Compute broker + OpenAI-compat client
│   ├── ens/                    ENS subname / text-record / access-token helpers
│   └── axl/                    AXL HTTP client + Mixture-of-Brains orchestrator types
├── contracts/                  Foundry: Brain, BrainOracle, BrainMinter, RoyaltyDistributor,
│                               SubnameRegistrar, AccessTokenRegistrar + lib/Errors
├── scripts/setup/              prep-deploy, register-parent, wire-ens, setup-compute,
│                               seed-from-vault, settle-royalties, push-segments
└── docs/                       0g-integration.md + architecture.md

The fastest path to verify Brainpedia works end-to-end on 0G mainnet.

1. Verify the contracts. Open any of the four mainnet addresses in the table above and click "verified source ↗" to see the Solidity source on chainscan.0g.ai. All four pass.
2. See the hero settlement on chain. chainscan.0g.ai tx 0x9a503d7c… settled 3 brains in one transaction via RoyaltyDistributor.distribute([1,2,3], [0.002, 0.0015, 0.0035], reason). Three Distributed events emitted in one block.
3. Try the web mint flow. Open brainpedia.up.railway.app/create, connect a wallet with 0G mainnet (Aristotle, chainId 16661), drop a folder containing any .md, .pdf, .docx, or .txt files, and sign the mint. The Brain is yours.
4. Query a Brain. Visit any Brain page via brainpedia.up.railway.app/<name> (start at yudhi) and run a mixture query through the demo widget.
5. Read the code. Start with contracts/src/Brain.sol, packages/knowledge-compiler/src/pipeline.ts, and apps/web/src/app/api/create/route.ts to see the three layers connect.

If a test wallet was provided in HackQuest reviewer notes, import that key and skip step 3's wallet creation.

Every cross-system value is environment-driven via .env.example. Contract addresses, RPC URLs, ENS parent name, and 0G provider details are never hardcoded in source.

bun install

# Run web + MCP locally
bun run dev

# Or use the published MCP server straight from npm
npx -y brainpedia-mcp

# Contracts
cd contracts
forge build
forge test

To deploy contracts to 0G mainnet:

# Brain + BrainOracle (wired together in one script)
forge script script/DeployBrain.s.sol \
  --rpc-url $ZG_RPC_URL --broadcast --verify
# Then deploy BrainMinter and RoyaltyDistributor against the Brain address
forge script script/DeployBrainMinter.s.sol --rpc-url $ZG_RPC_URL --broadcast --verify
forge script script/DeployRoyaltyDistributor.s.sol --rpc-url $ZG_RPC_URL --broadcast --verify

• All Solidity uses custom errors (src/lib/Errors.sol), Ownable2Step, ReentrancyGuard, and zero-address checks on every setter.
• Brain.secureTransfer requires an oracle-verified attestation bound to the live (tokenId, from, to) context. Standard ERC-721 transfers are blocked.
• Payments use pull-payment patterns (pendingWithdrawals + withdraw()) so a reverting recipient cannot DoS the system.
• Pre-mainnet review run via AI tooling (audit-prep + solidity-auditor). Four critical findings remediated; four accepted with documented reasoning in contracts/KNOWN_ISSUES.md. A human Pashov-style audit is targeted before any meaningful TVL.

• Yudhishthra Sugumaran (@0xYudhishthra on X, yudhishthra on Telegram)

MIT