Tenseuron Protocol

Tenseuron is an open protocol for coordinating AI work across independent miners and validators. Anyone can deploy an AI Network (a category of tasks with its own SPL token and economy), anyone can mine on it using their preferred AI provider, and anyone can submit tasks against it through the same OpenAI-compatible API surface they already know.

The protocol runs as a thin coordination layer on Cloudflare Workers + D1 + Solana. There is no central operator that can disable a network or seize a miner's rewards — every payout, burn, and pool refill is a real on-chain SPL transfer signed by a custodial backend wallet that is constrained to do exactly what the protocol rules dictate.

• AI Network. A category of tasks (e.g. text generation, code completion, image classification) with its own SPL token, bonding curve, and reward pool. Created through the Launchpad.
• Miner. A process that polls open tasks, runs them through an AI model, and submits the result. Miners earn 50% of each task's reward when validators accept their submission.
• Validator. A process that scores miner submissions 0–100 using its own AI. Validators earn 30% of the task reward, split across all validators that scored that submission.
• Operator (network creator). The wallet that deployed the network. Earns 10% of every task driven by others. Pays for their own usage like everyone else (locks the network token to submit) and is revenue-neutral on their own tasks — that 10% routes to treasury + burn instead, so a creator can't farm their own pool. Submits tasks via API key OR a 5-minute reusable wallet signature.
• Protocol Pool. A dedicated SPL account holding 20% of each network's total supply. This is the only fund miners/validators get paid from. Refilled by 0.7% of every curve trade (the other 0.3% goes to the protocol treasury).
• Managed compute. Optional: hand the protocol your encrypted AI API key and the platform runs your miner or validator loop server-side every minute. No local node required.

Tenseuron is a chain-agnostic protocol for coordinating AI work in the open. Anyone can launch an AI Network with its own token; anyone can mine it with any model — a paid API or a local GPU; independent validators score the work under an economically-secured consensus; and end users pay for AI through a simple compute API. It runs on Solana today.

Architecture

• AI Networks — each is a task market with its own SPL token and a bonding-curve market.
• Miners — answer tasks with any model: paid APIs (OpenAI, Anthropic, Groq, Mistral, DeepSeek, Gemini) or a local/GPU model (Ollama, LM Studio, any OpenAI-compatible endpoint).
• Validators — score miner submissions; the verdict is an economic consensus, not a single trusted grader.
• Compute API — POST /api/compute submits a task; results return once consensus completes (OpenAI-compatible endpoint supported).

Consensus — “verify, don't trust”

The verdict on each task is the stake-weighted median of validator scores — weighted by each validator's stake, reputation, and a reaction factor. Validators whose score lands far from the median are economically slashed, and that stake is redistributed to the honest validators of that same task; those who agree also earn a weight-proportional share of the reward. Skin-in-the-game needs no upfront capital: a slice of every miner/validator payout is auto-withheld into a slashable bond (earn-to-stake) that grows with the work you do.

• Real-user oracle. WalletAI's reaction emojis (👍 / love / nailed / 👎) feed back into scoring, grounding validation in genuine user feedback — an outcome signal a pure validator network doesn't have.
• Signed scores. Independent validators sign each score (ed25519) with their wallet; the backend verifies and tags it attested='self' vs 'backend' for managed ones.
• Publicly recomputable. GET /api/consensus/:taskId returns every score, its exact weight, and the recomputed median — anyone can re-derive the verdict and check each signature.
• Anchored on-chain. Every hour a hash of the period's verdicts is written to Solana, so verdict history can't be silently rewritten.

Economics

Each network's token funds its own work. Per-task rewards split 50% miner / 30% validators / 10% creator / 10% treasury, decay slowly as the pool drains and refill from trading. Each task also consumes a small usage fee from the submitter's locked tokens, split 50% burned / 50% to treasury. Once a curve raises ~85 SOL it graduates to a Raydium pool with locked (burned-LP) liquidity. See Token economy for the full mechanics (the 1% total trader cost: 0.7% pool refill + 0.3% treasury).

Trust & custody

Funds and evidence are being made trust-minimized without freezing the product. The bonding curve is moving to an on-chain program that holds the reserve in a program-owned vault with no admin-withdraw — tokens leave only via buy/sell at the curve price, so nobody (including the team) can pull the reserve. That program is built and proven on devnet; it goes to mainnet after a security audit (see Roadmap).

Security

• Anti-snipe buy caps — per-transaction and per-wallet limits on bonding-curve buys; over-cap buys are auto-refunded, so no single wallet can corner a fresh token.
• Fixed supply — token mint authority is revoked at deploy; supply can't be inflated.
• Single guarded path — all trading goes through one slippage-protected AMM; legacy no-slippage routes are retired.

Tokens

TAI is the protocol token (validator staking, consensus weight, and governance). WAI is the WalletAI application token. Both are fair-launch, fixed-supply, bonding-curve tokens with mint authority revoked.

Note — the precise allocation tables are being finalized and will be published here; what's confirmed on-chain today: fixed supply, mint authority revoked, and no founder pre-mine taken to date.

Honest caveat: custody today is still backend-key-held (with a public balance monitor); full trustlessness scales with independent self-signing validators and the on-chain program after audit. We document the gap rather than hide it.

The fastest path to mining or validating, regardless of where you live in the stack:

# 1. Install Ollama from https://ollama.com  (one click)
ollama pull llama3.2:1b

# 2. Install the CLI
npm install -g @tenseuronp/cli

# 3. Set up — wizard auto-detects models on your machine
tenseuron miner setup

# 4. Run with live dashboard
tenseuron miner --dashboard

curl -X POST https://api.tenseuron.com/api/compute \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"input":"Hello","mode":"fast"}'

# Poll the returned taskId for the result:
curl https://api.tenseuron.com/api/compute/task_…

Miners pick up open tasks, run them through their AI of choice, and submit the output. There are two ways to mine: managed (platform runs you) or self-hosted (you run the CLI locally).

Managed mining

Register at tenseuron.com/miner. The platform encrypts your API key at rest with AES-GCM and runs your miner every cron tick. Rewards land in your wallet automatically. Pause, resume, or remove from the same page.

When to choose this: you have a cloud API key (DeepSeek is cheapest), you don't want to keep a terminal open, you're fine with the protocol holding your encrypted key.

Self-hosted mining

Run the published CLI from any machine with Node.js 18+:

npm install -g @tenseuronp/cli
tenseuron miner setup     # interactive wizard
tenseuron miner           # starts the loop
tenseuron miner --dashboard   # live TUI stats panel

The wizard prompts for: AI network, your Solana wallet address, provider (defaults to Ollama since the CLI is built for local-LLM operators), model, endpoint. For Ollama / LM Studio it auto-detects installed models so you don't have to type names.

Local mining requires no API key — the CLI writes API_KEY=local and points the loop at your local server (default http://localhost:11434/v1).

Reward math

• Per-task budget = poolBalance × 5e-9 (continuous decay).
• Winning miner: 50% of budget.
• Validators (split): 30% of budget.
• Network creator: 10%.
• Launchpad treasury: 10%.

On a fresh 200M-token pool, that's ~0.5 tokens to the miner per task. Reward shrinks as the pool drains but never reaches zero, and the pool grows again whenever someone buys/sells the token (0.7% of every trade refills it; the other 0.3% goes to the protocol treasury).

Earn-to-stake

A configurable slice of each miner/validator payout is auto-withheld into a per-network bond — slashable skin-in-the-game you build straight from earnings, no upfront capital. The bond boosts your consensus weight, is slashed before any upfront stake if you misbehave, and is withdrawable (minus any slashing) after a cooldown. The earlier and more you work, the bigger your bond compounds.

Validators score miner submissions 0–100 using their own AI. A task only completes once a validator has accepted the submission, so validators are critical to network liveness.

The same CLI does both — and either managed or self-hosted:

tenseuron validator setup
tenseuron validator
# or
tenseuron validator --dashboard

Reputation & cooldown

• New validators start at reputation 50.
• The verdict is the stake-weighted median of validator scores (weighted by stake/bond × reputation × reaction factor). Scoring near the median = reputation +1 and a weight-proportional reward; scoring far from it = −1 and a small slash that's redistributed to the honest validators of that task (bond slashed before upfront stake). See the Whitepaper for the full consensus design.
• Reputation < 10 = shadow-banned (work still consumed, no payout).
• Reputation = 0 = full ban.
• Leaving a network with low reputation triggers a 3-day (shadow-banned) or 14-day (banned) cooldown before the stake is released. Good standing = instant leave.

Anti-self-validation

A validator cannot score submissions from its own wallet. If you want to mine AND validate on the same network, use a different Solana wallet for the validator.

Self-signed scores (verifiable)

Set VALIDATOR_PRIVATE_KEY in your validator config and the CLI signs each score with your wallet (ed25519). The backend verifies it and tags the score attested='self' — anyone can independently re-verify it via GET /api/consensus/:taskId. It's optional (unsigned scores still work) but it's what makes a validator's grading independently trustworthy. Your key stays local and is never sent to the backend.

Network creation requires a Phantom signature (you're paying SOL to deploy the token + the bonding curve). It happens entirely in the browser at tenseuron.com/launchpad/ai-networks/create.

1. Pick a category & scoring type. Validator-scored (free-form, default) or deterministic (auto-scored against an expected output).
2. Configure tokenomics. Supply (default 1M), symbol, decimals. The protocol enforces the allocation policy automatically:
   • 0% to creator (no founder dump risk)
   • 20% to the Protocol Pool (only spendable on miner/validator payouts)
   • 80% to the bonding curve (tradable pre-graduation)
3. Sign the SOL payment. Backend deploys the SPL token with authority set to null (no further mints possible), creates the protocol pool ATA, seeds the bonding curve.
4. Optional first buy. Right after deploy, a success window offers a capped first buy of your own token (pump.fun-style) — be the first in, capped for a fair launch (anything over the cap is auto-refunded). Skippable.
5. Lock to operate. You use your own network like everyone else — lock some of its tokens before you can submit tasks. See “Lock & Burn” below.

Once active, your network shows up in the public AI Networks list, anyone can mine or validate on it, and you can submit tasks via API.

Two auth modes:

• Bearer token — for servers and dev hubs. Generate at /developer → Keys. A new key is created inactive and activates once you lock the network's token (Lock tab) — locking is what funds your usage.
• Wallet signature — for browser extensions and apps where the user has Phantom. Sign tenseuron-compute:<networkId>:<unix-rounded-to-5min> once and reuse for 5 minutes; no popup per request.

Submit a task

POST /api/compute
Authorization: Bearer tk_…

{
  "input": "Explain Solana account model in 2 sentences",
  "mode": "fast",          // "fast" = 1 submission, "consensus" = N+ (default 3)
  "rewardAmount": "1",     // optional — defaults to network's minerRewardPerTask
  "webhook": null          // optional — POST here when complete
}

→ { "data": { "taskId": "task_…", "status": "pending", ... } }

Poll the result

GET /api/compute/<taskId>

→ { "data": { "taskId": "task_…", "status": "complete", "output": "…" } }

OpenAI-compatible

Drop-in replacement for the OpenAI SDK — point OPENAI_API_BASE at the Tenseuron backend, use any active network ID as the model name:

POST /v1/chat/completions
Authorization: Bearer tk_…

{
  "model": "<network_id>",
  "messages": [{ "role": "user", "content": "Hello" }]
}

The /v1/models endpoint lists every active network as if it were a model. The protocol routes the request to the network's miners, runs inference + validation, and returns the winning submission in OpenAI's response shape.

Every AI Network has its own SPL token. The economy is designed to be self-balancing — payouts shrink slowly as the pool drains, and grow again whenever the token trades. Three forces:

Per-task split

miner     : 50%   ← winning submission
validators: 30%   ← scored the winning submission
creator   : 10%   ← from OTHERS' tasks (creator's own tasks → treasury+burn)
treasury  : 10%   ← protocol treasury

usage fee : small % of budget from submitter's lock → 50% burned / 50% treasury
earn-bond : a slice of each miner/validator payout → slashable per-network bond
refill    : 0.7% of trade token-side → network pool
treasury  : 0.3% of trade SOL-side → protocol treasury
graduate  : curve fills (~85 SOL) → Raydium pool, LP burned (liquidity locked)

To submit tasks against a network, the submitter must have locked network tokens covering at least one usage fee. Everyone who uses a network locks — including the network creator (no exemption) — which is exactly what gives each network's token real demand. It's also a sybil/spam guard.

Where: Developer Hub → Lock tab → select network → enter amount. A Phantom signature sends tokens from your wallet to the backend ATA; the backend verifies on-chain, credits your lock, and activates any inactive API key you hold for that network.

How much: Each task consumes a small usage fee — a fraction of the per-task budget, scaled so a lock lasts many tasks — split 50% burned / 50% to treasury. Locking a handful of the network's tokens buys hundreds of tasks of runway; top up when it runs low, and only what you actually use is ever consumed.

The lock also gates the API: POST /api/compute returns INSUFFICIENT_LOCK 402 if your balance is below one usage fee, and a freshly generated API key stays inactive until you lock.

Install: npm install -g @tenseuronp/cli (or run any command via npx @tenseuronp/cli ... without installing).

Commands

Config files

Setup writes to ~/.tenseuron/miner.env and ~/.tenseuron/validator.env. Edit them by hand at any time — the next CLI run picks up the changes. Keys are stored plaintext on disk; protect accordingly.

Supported providers

• Local: Ollama, LM Studio, any OpenAI-compatible endpoint.
• Cloud: DeepSeek, OpenAI, Anthropic, Groq, Mistral, Gemini.

For Ollama / LM Studio the CLI auto-queries your local server during setup and lets you select from installed models. No need to remember the exact tag.

The vision, in phases — from a Solana launch to a multi-chain, community-owned AI economy.