Developers - Bitcoin Attestation Network

AI-Powered Development

Lead a Team of AI Agents From Your Terminal

You don't just use one AI. You lead a team. Blockie TalkieTM lets you run multiple AI agents simultaneously, each with their own model, their own task, and their own voice. You're the operator. They work for you.

Multi-Agent Dispatch

Launch Elliott on a code review while a second model writes tests and a third scans for vulnerabilities. Each agent runs independently. You monitor all of them from one console. Dispatch work across your mesh to machines with more RAM.

Any Model. Your Choice.

Elliott runs local GGUF models by default. Connect Claude Code, OpenAI, Ollama, LM Studio, or any compatible CLI. Mix local and cloud models in the same session. The terminal is provider-agnostic. Your data stays local unless you choose otherwise.

Voice-Enabled AI Chat

Talk to your agents. They talk back. Per-agent voice personalities via the speech pipeline. Speech-to-text, text-to-speech, and voice cloning all running locally on consumer CPU. Hands-free development. Speech queue ensures one speaks at a time.

Agent Task Swarms

Launch a swarm of agents on a complex task. Each takes a piece. Results merge back. PQ-signed attestations track every agent's contribution with before/after SHA3-512 hashes. Full provenance of who wrote what.

Verified AI Work

Every inference submits a cognition proof. Every model you compile produces Model Build receipts. Every LoRA adapter you share can build community reputation. When enabled, verified AI work can qualify for qBTCTM share allocations.

Chain-Aware Context

Elliott reads from Synthetic RAMTM, a knowledge index built from consensus-verified Memory BlocksTM. The AI knows the chain. It knows AttestoScript. It knows your project. Context grounded in verified facts, not internet scrapes.

Model Economy

Build Models. Share Over Mesh. Record Verified Work.

Every developer on the network is a model builder. Build supervised datasets from finalized attestos and Memory Blocks. Train locally. Share artifacts with provenance. When enabled, model publication and inference receipts can qualify for qBTCTM share allocations. No corporate model registry required.

Build SFT Datasets from Finalized Memory BlocksTM

The current pipeline extracts finalized attestos and Memory Blocks into supervised fine-tuning datasets. Local-only knowledge can be included on your own node, but finalized chain data remains the canonical source of truth. Every fact carries provenance and consensus depth.

Share LoRA Adapters Over Mesh

Don't share raw data. Share small LoRA adapters that capture local specialization without exposing the underlying dataset. Your data stays on your node, while model artifacts can still move through the mesh with signed provenance.

Publish GGUF Models

Merge adapters into base weights, export GGUF for local runtime, and record dataset build, training run, model export, and canonical binding receipts. Every model artifact is content-addressed and PQ-signed with full provenance from source material to deployed runtime.

Work Receipts Everywhere

Compile a model? Generate Model Build receipts. Run inference? Generate AI Cognition receipts. Publish a LoRA adapter the community uses? Build reputation and an auditable work trail. When enabled, those receipts can qualify for qBTCTM share allocations.

      # Build the supervised dataset from finalized attestos + MBLKs

      PROOFNET_ROOT=$PWD python3 backend/ai/datasets/build_attesto_sft.py

      # Train Elliott's local LoRA adapter on Qwen 2.5 7B

      PROOFNET_ROOT=$PWD BASE_MODEL=Qwen/Qwen2.5-7B-Instruct \

      python3 backend/ai/training/train_elliott_lora.py

      # Merge adapter into base weights, then export GGUF

      BASE_MODEL=Qwen/Qwen2.5-7B-Instruct LORA_DIR=backend/data/ai/models/elliott_lora \

      OUT_DIR=backend/data/ai/models/elliott_base_hf python3 backend/ai/training/merge_lora.py

      OUT_DIR=backend/data/ai/models/elliott_base_hf GGUF_OUT=deps/models/elliott_base.Q4_K_M.gguf \

      GGUF_CPP_DIR=/path/to/gguf-backend bash backend/ai/training/export_to_gguf.sh

Your Terminal

Blockie TalkieTM: The Developer Terminal for the Bitcoin Economy

Blockie Talkie is a developer terminal with AI, mesh networking, and blockchain built in. Connect your preferred AI CLI, whether Elliott (local GGUF), Claude Code, OpenAI, or any compatible provider. The terminal is provider-agnostic and reimagines development for the Bitcoin economy.

Grouped Command Blocks

Outputs grouped by command. Searchable history. Inline editing. Command outputs grouped visually. Searchable. Inline editing. Modern terminal UX, connected to the Bitcoin economy.

Elliott CLI Auto-Loaded

Elliott runs local GGUF models on launch. Connect any AI CLI you prefer, including Claude Code, OpenAI, or community models. The terminal is provider-agnostic. Your data stays local by default.

AI Group Chat

Collaborate with multiple local AI models in one workspace. Elliott and community GGUF models. Voice-enabled with per-agent personalities. Speech queue for turn-taking.

Mesh Dispatch

Send heavy builds to remote mesh machines. RAM relief routing. Worker registry. Your laptop dispatches, your server compiles. Verified build receipts can qualify for Model Build Shares when enabled.

GitNode Integration

PQ-signed commits from the terminal. Repos replicate across mesh. Code attestations with SHA3-512 before/after hashes. Bitcoin-anchored audit trail.

Cloud + Trade + Resources

Allocate mesh RAM and CPU from the Cloud tab. Peer-to-peer trade on the Trade tab. Monitor all nodes, services, and work receipts in one console.

      # Launch Blockie Talkie - everything starts automatically

      # Bitcoin node syncs, Proofnet consensus runs, Elliott loads GGUF model

      $ elliott "review this AttestoScript for security issues"

      Elliott: Analyzing... No delegatecall, no selfdestruct, no unbounded loops.

               64-step cap respected. All signatures ML-DSA-65. Script is clean.

      $ ban mesh dispatch --job "compile gguf qwen2.5-7b" --target rode

      Dispatched to rode (64GB i9). Estimated: 12 min. Model Build Share queued.

      $ git commit -S --pq-sign -m "feat: add synthetic_swap operation"

      PQ1 signature: ML-DSA-65 (3,309 bytes). Attesto committed to mesh.

      $ ban ai cognition prove --session latest

      Cognition proof submitted. Nonce verified. AI Cognition Share earned.

Mesh Infrastructure

Toshi Cloud: Machine, Service, and Block Control

The Cloud tab inside Blockie TalkieTM is your operator control plane. Add devices, share resources, deploy services, and manage your entire mesh from one interface. No AWS. No cloud provider. Your machines, your network.

N+

Online Machines

Known systems in your local mesh

Shared RAM

Pooled Memory

CPU cores available across active machines

Storage

Shareable Volumes

Root and external volumes visible to Toshi Cloud

Links

Desktop Systems

Mounted systems ready for local promotion

Local Mesh Control

Install once, add devices in a browser, then share the whole local system. Local machines feel like one trusted network. Non-local nodes get scoped grants, receipts, and pricing.

What Can Be Shared

CPU + RAM: Leased compute for AI and builds. Storage: Vaults, folders, SSDs. Services: Full node, wallet, Elliott, voice. Blocks: VMs and desktop spaces.

Add Device Share Resources Create Block Deploy Service Open Console Logs

Smart Contracts Reimagined

AttestoScriptTM

No virtual machine. No gas metering. No reentrancy. No Solidity. AttestoScript is a deterministic JSON program that compiles into an execution plan using native UTXO lane operations. Maximum 64 steps per script. Every operation is bounded, auditable, and PQ-signed.

    // AttestoScript example: issue a credential

    {

      "version": "1.0",

      "type": "issue_credential",

      "issuer": "node_f486897d66783fd7",

      "subject": "node_a1b2c3d4e5f6g7h8",

      "claims": {

        "type": "food_handler_permit",

        "issued": "2026-04-03",

        "expires": "2028-04-03",

        "jurisdiction": "cache_county_utah"

      },

      "signature": "ML-DSA-65...",

      "digest": "SHA3-512..."

    }

28 Operations Across Six Categories

Financial (11)

send

Transfer qBTC between addresses

batch_send

Multi-output transaction in one attesto

synthetic_send

Transfer synthetic assets

synthetic_batch_send

Multi-output synthetic transfer

publish_attesto

Publish any typed attestation to chain

timelock_lock

Lock funds until a future block height

multisig_lock

m-of-n escrow with PQ signatures

htlc_lock

Hash time-lock for atomic swaps

htlc_claim

Claim HTLC with preimage

htlc_refund

Refund expired HTLC

noop

No-op for script padding

Identity and Credentials (5)

issue_credential

Issue a PQ-signed verifiable credential

revoke_credential

On-chain credential revocation

present_credential

Selective disclosure presentation

register_name

Claim a .btc domain and identity

delegate_authority

Grant permission to another PQ key

pBTC Vault (3)

pbtc_lock

Deposit BTC into Taproot vault, mint pBTC

pbtc_unlock

Burn pBTC, release BTC from vault

pbtc_prove

Submit SPV proof of Bitcoin deposit

Synthetics (3)

synthetic_mint

Create new synthetic asset (any chain, any real-world asset)

synthetic_burn

Destroy synthetic tokens permanently

synthetic_swap

Atomic swap between synthetic assets

AI and Knowledge (3)

publish_knowledge

Submit knowledge attesto (5,000 + 1,000/KB sats, burned)

submit_cognition_proof

Prove local AI inference work

submit_model_hash

Governance (3)

threshold_sign

m-of-n multi-party PQ signing

escrow_release

Conditional escrow based on attesto conditions

vote

On-chain governance weighted by PoW participation

EVM Integration

BAX: Universal Chain Bridge

BAX is designed to connect major blockchains to the Bitcoin economy through chain-specific vault and intent-translation infrastructure. Planned routes include Ethereum, Solana, Cosmos, Aptos, Sui, Cardano, XRPL, Lightning, Dogecoin, and EVM networks. Public deposit flows are not enabled today. The Toshi Wallet Extension injects native providers for each chain, AttestoScript compiles the intent, and enabled routes settle as attestations in Memory Blocks anchored to Bitcoin.

      // EVM intent captured from MetaMask

      // ERC-20 transfer: USDT.transfer(recipient, 1000)

      // BAX translates to AttestoScript:

      {

        "type": "synthetic_send",

        "lane": "synthetics",

        "asset": "sUSDT",

        "to": "node_recipient_address",

        "amount": 1000,

        "evm_receipt": "intent_execution_receipt..."

      }

Supported EVM Patterns

ERC-20

Fungible tokens
Transfer, approve, allowance

ERC-721

Non-fungible tokens
Mint, transfer, metadata

ERC-1155

Multi-token standard
Batch transfers, mixed assets

ERC-4626

Tokenized vaults
Deposit, withdraw, yield

Static Safety Analysis

BAX rejects dangerous EVM patterns before they execute:

Rejected: delegatecall

Proxy contract attacks eliminated

Rejected: selfdestruct

Contract destruction impossible

Rejected: unbounded loops

64-step cap enforced

The attack surface that has cost billions on Ethereum, reentrancy ($3.6B+), flash loan exploits, delegatecall vulnerabilities, is structurally eliminated. Not mitigated. Eliminated.

AI Agent Payments

X402 Protocol

X402 extends HTTP 402 (Payment Required) with post-quantum signatures. AI agents are designed to pay for resources autonomously over PQTLSTM channels. The node's ML-DSA-65 identity IS the payment credential.

    // X402 payment header

    POST /api/v1/knowledge HTTP/1.1

    Host: node_f486897d.toshi.btc

    X-402-Payment: attesto

    X-402-Amount: 5000

    X-402-Signer: ML-DSA-65:node_f486897d

    X-402-Signature: <3309-byte PQ signature>

    X-402-Session: per-origin, auto-revoke

    Content-Type: application/json

    // Agent publishes knowledge, pays in qBTC, all PQ-signed

Per-Origin Approval

Each service endpoint requires explicit approval. No blanket permissions. Agents authorize specific nodes for specific actions.

Session Limits

Set maximum spend per session. Automatic revocation when limits are reached. No runaway agent spending.

Automatic Revocation

Sessions expire. Compromised agents are cut off. No standing authorization that persists beyond the session scope.

PQ-Signed Everything

Every payment header carries an ML-DSA-65 signature. Quantum computers cannot forge agent payments. Ever.

Architecture

Five UTXO Lanes

Each lane has its own SQLite ledger, independent validation rules, and per-lane SHA3-512 state digest. Lanes process in parallel. A surge in synthetics has zero impact on qBTC settlement.

qBTC

Native currency
21M cap
Mined via PoK

pBTC

Bitcoin peg
1:1 Taproot vault
SPV verified

aBTC

Application
Epoch minting
Pool integration

tBTC

Testnet
Faucet endpoint
Development

Synthetics

Any asset
Any chain
Unlimited namespaces

Get Started

SDK and Tools

    # Install the BAN development toolkit

    curl -sSL https://bitcoinattestationnetwork.org/install.sh | bash

    # Initialize a new node (Wallet + Earn preset)

    ban init --preset wallet-earn

    # Start your node (runs Bitcoin Core + Proofnet + BTCore)

    ban start

    # Check status

    ban status

    Node: online

    Bitcoin: syncing (block 695,450)

    Proofnet: consensus active

    Elliott AI: ready

    Identity: f486897d@toshi.btc

    # Submit an attesto

    ban attesto submit --type qbtc_tx --to node_a1b2c3 --amount 100

    # Query your UTXO balance across all lanes

    ban wallet balance --all-lanes

    qBTC:  1,250.00000000

    pBTC:     0.50000000

    sETH:    12.00000000

    sSOL:   100.00000000

Rust SDK

Native Rust bindings to the ProofnetTM consensus engine. Direct UTXO manipulation, attesto construction, PQ signature creation. Zero overhead.

Python SDK

High-level Python bindings for rapid prototyping. ElliottTM AI integration, knowledge publishing, model training orchestration.

JavaScript/TypeScript SDK

Browser and Node.js compatible. Web3 wallet integration, AttestoScript construction, PQTLSTM client connections.

CLI Tools

Command-line interface for node management, attesto submission, wallet operations, mining control, and AI model management.

Interoperability

The Quantum-Secure Settlement Layer for All of Crypto

Every chain keeps its community, its tokens, its dApps. BAN is designed to provide the bridge, the post-quantum security stack, the speed, and the Bitcoin anchor. One network connecting everything as those routes roll out.

10 Chain Bridges

Planned vault programs span Ethereum, Solana, Cosmos, Aptos, Sui, Cardano, XRPL, Lightning, Dogecoin, and EVM networks. Chain-specific watcher services support enabled routes. Native wallet signing remains chain-specific.

Quantum-Safe From Contact

External chains use their native signing (ECDSA, Ed25519). Assets that enter BAN are re-signed under ML-DSA-65. BAN applies its post-quantum stack at the boundary while external chains remain responsible for their own security models.

Native Wallet Injection

Toshi Wallet Extension injects window.ethereum, window.solana, window.cosmos, window.aptos, window.sui. Users interact with existing dApps using existing wallets. BAX translates the intent.

Atomic Cross-Chain Swaps

HTLC locks enable trustless swaps between any chain's synthetic assets. Swap sETH for sSOL in one atomic transaction. No bridge tokens. No wrapped assets. Just PQ-signed attestations.

Ethereum Solana Cosmos Aptos Sui Cardano XRPL Lightning Dogecoin All EVM Networks

Bitcoin's security. Every chain's assets. Millisecond speed. Quantum-resistant. On consumer hardware.

Education

Student Network: Learn Bitcoin by Building on It

Not a textbook. Not a simulation. A real post-quantum blockchain running on real Bitcoin nodes. The Student Network gives universities, technical colleges, and K-12 programs hands-on access to the same infrastructure professionals use. Students don't read about blockchain. They run it.

🎓

Universities

Students study real blockchain architecture. Not theory from a textbook. A running UTXO engine, consensus system, and AI pipeline they can inspect, modify, and test. CS, cybersecurity, and CTE programs get a hands-on lab built in Utah.

🏫

Technical Colleges

Welding certifications, HVAC licenses, nursing credentials. Students earn verifiable attestations that live on their device permanently. Employers verify instantly. The credential outlives the school's database.

🏛

K-12 and Community

Student achievement records, extracurricular certifications, community service hours. Build a verifiable portfolio that follows students through college and career. Owned by the student, not the school.

Protonet: The Research Sandbox

Every node includes Protonet, a local simulation environment where students and researchers experiment without touching production systems or risking real assets.

      # Start a Protonet sandbox

      ban protonet init --students 30 --preset classroom

      # Students create their own node identities

      ban protonet join --name "student_maria" --preset wallet-earn

      # Issue a credential (professor to student)

      ban attesto submit --type issue_credential \

        --claims '{"type":"blockchain_fundamentals","grade":"A","semester":"spring_2026"}' \

        --subject student_maria@toshi.btc

      # Student verifies their credential - portable, permanent, on-device

      ban wallet credentials list

      blockchain_fundamentals (Utah State University, Spring 2026) - VERIFIED

For Bitcoiners

Teach the next generation Bitcoin's principles: proof of work, self-custody, UTXO model, sound money. The Student Network runs real Bitcoin nodes. Students don't learn about Bitcoin from slides. They validate blocks.

For Educators

Add Protonet labs to existing CS, cybersecurity, and CTE courses without buying new infrastructure. Students publish papers on real post-quantum cryptography using a system built at their own university.

For Students

Graduate with hands-on blockchain experience. Your credentials are verifiable attestations on your device, not a PDF from the registrar. Employers check them instantly. Your portfolio is Bitcoin-anchored.

For Utah

Utah passed the laws. Utah built the technology. The Student Network lets Utah's institutions learn and deploy it first. When other states ask how, the reference implementation is already running in Logan.

Utah passed the laws. We built the technology. The Student Network puts it in their hands.

Developer Hub