A reference framework and executable blueprint for decentralized AI coordination networks.
Tenseuron defines TDCP (Tenseuron Decentralized Coordination Protocol) and provides a complete, opinionated implementation of economic policy, security mechanisms, and lifecycle management for adversarial AI task networks.
Tenseuron is not a minimal wire protocol.
It is a reference network — a complete, runnable system that encodes one coherent equilibrium for how autonomous agents coordinate, evaluate work, manage risk, and distribute value under adversarial conditions.
Think of it as:
- Kubernetes for AI coordination
- A living blueprint, not a specification PDF
- An opinionated framework designed to be forked and adapted
It includes:
- ✅ TDCP - The minimal coordination protocol (Layer 1)
- ✅ Network Policy - Reputation, risk scoring, anti-gaming (Layer 2)
- ✅ Economic Layer - Creator revenue, settlements, money flow (Layer 3)
The spinal cord - minimum required for coordination
- Task schema and lifecycle
- Agent identity and roles (Miners, Validators, Creators)
- Claim/execute/submit flow
- Evaluation result format
- Reward signal structure
This is the protocol. Everything else is reference implementation.
The immune system - how the network behaves under adversarial conditions at scale
- Reputation systems
- Risk scoring
- Collusion detection and prevention
- Sybil resistance
- Graduation mechanics
- Bootstrap mode
These are design choices, not protocol requirements. See FORK_GUIDE.md for alternatives.
The organism - full economic and operational layer
- Creator economics and revenue distribution
- Payment flows and settlements
- Blockchain integration (Ethereum, Polygon, Solana)
- Storage systems (IPFS, R2, S3, Arweave)
- Database adapters (Prisma, D1, MongoDB)
This is one working equilibrium for decentralized AI labor markets.
Tenseuron encodes specific assumptions:
Adversarial-First Design
- Agents will try to game the system
- Collusion is inevitable at scale
- Trust must be earned, not assumed
Economic Realism
- Coordination requires incentives
- Free-riding must be disincentivized
- Value flows must be explicit
Decentralization ≠ Neutrality
- The reference network has opinions
- Defaults are design choices
- Forks are governance
See PHILOSOPHY.md for the complete worldview.
npm install @zananova/tenseuron-protocolimport { createProtocol } from '@zananova/tenseuron-protocol';
// Auto-detects runtime (Node.js, Cloudflare Workers, Deno, Bun)
const { networkRepo, storage, blockchain } = createProtocol({
database: { type: 'prisma', instance: prisma },
storage: { type: 'ipfs' },
blockchain: {
type: 'polygon',
rpcUrl: process.env.POLYGON_RPC_URL,
privateKey: process.env.DEPLOYER_PRIVATE_KEY
}
});import { ProtocolServiceFactory } from '@zananova/tenseuron-protocol';
import { Logger } from './utils/Logger';
import { PrismaClient } from '@prisma/client';
const prisma = new PrismaClient();
const logger = new Logger('Protocol');
// Creates full reference network with all policies
const protocol = ProtocolServiceFactory.createForNode(logger, prisma);
// Create a network
const network = await protocol.createNetwork({
creatorAddress: '0x...',
aiModuleId: 'gpt-4',
initialBudget: '1000000000000000000', // 1 ETH
taskType: 'text-generation'
});Works with any database through adapters:
- Prisma (PostgreSQL, MySQL, SQLite)
- D1 (Cloudflare)
- MongoDB
- Custom adapters
Runs anywhere:
- Node.js (Express, Fastify)
- Cloudflare Workers
- Deno
- Bun
Supports multiple chains:
- Ethereum
- Polygon
- Solana
- Custom providers
Multiple storage backends:
- IPFS
- Cloudflare R2
- AWS S3
- Arweave
See ARCHITECTURE.md for detailed layer breakdown.
The reference network includes opinionated defaults:
Economic:
- Creator revenue: 70/30 split
- Validator rewards: Performance-based
- Graduation threshold: 1000 successful tasks
- Bond requirements: Risk-adjusted
Security:
- Collusion detection: Multi-signal analysis
- Sybil resistance: Stake + reputation
- Risk scoring: Exponential decay
- Scam defense: Pattern recognition
Lifecycle:
- Bootstrap mode: First 100 tasks
- Graduation: Automated based on metrics
- Network sunset: Inactivity-based
Why these choices? See PHILOSOPHY.md
Want different policies? See FORK_GUIDE.md
See DEFAULT_POLICIES.md for complete list.
- Task Management - Create, claim, execute, evaluate tasks
- Network Management - Create and manage AI task networks
- Agent Identity - Miners, Validators, Creators
- Risk Scoring - Evaluate network and agent risk
- Collusion Prevention - Detect and prevent coordinated attacks
- Sybil Resistance - Prevent identity manipulation
- Reputation - Track agent performance over time
- Graduation - Manage network lifecycle and privileges
- Money Flow - Track value movement through the network
- Settlement - Execute payments and rewards
- Creator Revenue - Manage creator economics
- Scam Defense - Protect against fraudulent networks
// Prisma (PostgreSQL)
import { PrismaNetworkRepository } from '@zananova/tenseuron-protocol/adapters';
// Cloudflare D1
import { D1NetworkRepository } from '@zananova/tenseuron-protocol/adapters';// Ethereum/Polygon
import { EthereumProvider } from '@zananova/tenseuron-protocol/adapters';
// Solana
import { SolanaHTTPProvider } from '@zananova/tenseuron-protocol/adapters';// IPFS
import { IPFSStorageProvider } from '@zananova/tenseuron-protocol/adapters';
// Cloudflare R2
import { CloudflareR2StorageProvider } from '@zananova/tenseuron-protocol/adapters';Tenseuron is designed to be forked, not followed blindly.
You can:
- Strip down to TDCP only
- Replace economic policies
- Swap security mechanisms
- Change graduation rules
- Use different reputation models
See FORK_GUIDE.md for:
- How to create a minimal TDCP implementation
- How to replace default policies
- Example alternative economic models
- Custom adapter creation
See examples/minimal-tdcp/ for a stripped-down implementation with zero opinions.
See examples/custom-economics/ for alternative revenue distribution.
See examples/custom-risk/ for different risk evaluation logic.
git clone https://github.com/zananova/Tenseuron-Protocol
cd Tenseuron-Protocol
npm installnpm run buildnpm testTenseuron does not use votes or DAOs.
Code = Policy Changes happen through code contributions.
Forks = Governance
Deep disagreements result in forks. That's real decentralization.
Reputation = Influence Contributors earn influence through:
- Code quality
- Economic experiments
- Attack simulations
- Policy improvements
See GOVERNANCE.md for details.
We welcome contributions that:
- Improve economic models
- Add attack simulations
- Experiment with policy alternatives
- Create new adapters
- Enhance security mechanisms
We do not accept:
- Feature requests without rationale
- Simplification for simplification's sake
- Removal of "complexity" without understanding its purpose
See CONTRIBUTING.md for guidelines.
- PHILOSOPHY.md - Why Tenseuron makes these choices
- ARCHITECTURE.md - Three-layer breakdown
- FORK_GUIDE.md - How to adapt Tenseuron
- DEFAULT_POLICIES.md - Reference network policies
- GOVERNANCE.md - How decisions are made
- API.md - Complete API reference
MIT License - See LICENSE
- GitHub Issues: Bug reports and feature discussions
- Discussions: Design questions and policy debates
- Discord: Real-time coordination (coming soon)
Tenseuron is built on the shoulders of:
- Bittensor (coordination inspiration)
- Ethereum (economic primitives)
- IPFS (decentralized storage)
- The adversarial systems research community
Tenseuron is not trying to be everything to everyone.
It is one coherent answer to the question:
"How should autonomous agents coordinate at scale under adversarial conditions?"
If you have a different answer, fork it. That's the point.