GitHub - AdvaitaLabs/Setu: Setu is a causally driven distributed ledger system designed for the AI-native economy. Different from traditional blockchains that generate blocks according to a physical clock, FoldGraph drives the ledger forward with a verifiable logical clock (VLC), and records the history only when actual intelligent work is generated

 ███████╗███████╗████████╗██╗   ██╗
 ██╔════╝██╔════╝╚══██╔══╝██║   ██║
 ███████╗█████╗     ██║   ██║   ██║
 ╚════██║██╔══╝     ██║   ██║   ██║
 ███████║███████╗   ██║   ╚██████╔╝
 ╚══════╝╚══════╝   ╚═╝    ╚═════╝

The ledger that ticks when AI agents work — not when miners do.

A causally-driven distributed ledger purpose-built for AI agent economies.
Replace physical time + miners with verifiable work + TEE attestation.

⚡ Quick Demo · 🛠 Use Cases · 🏗 Architecture · 📦 Get Started · 📚 Docs · 💬 Discord

⚡ What is Setu

Tip

30-second pitch: If you're shipping AI agents that act thousands of times per second, you need a substrate that records, proves, and settles their work — without the cost, latency, or trust assumptions of traditional blockchains. Setu is that substrate.

If you're building AI agents that need to:

🔐 Prove work was done With cryptographic TEE attestation	💸 Get paid by other agents In milliseconds, no gas wars
🏆 Build verifiable reputation On-chain, queryable by anyone	🔗 Coordinate without trust No central server, no oracle

...Setu gives you the substrate.

🆚 Setu vs Ethereum

Think of Setu as "Ethereum for AI agents" — except:

	🟧 Ethereum	🟦 Setu
Block trigger	⏰ Physical time (12s)	⚡ Causal work events
Execution	📖 Public VM	🛡 TEE enclave (Nitro)
Ordering	🕒 Global clock	🔢 Vector Logical Clock
Throughput	`~30 TPS`	`200K-300K TPS`
Finality	`~12 seconds`	`50-100ms`
Gas auctions	💸 Yes	✨ None

🚀 Quick Demo

Note

60 seconds. Zero config. First transaction recorded.

# 1️⃣  Clone and start a local Setu network
git clone https://github.com/AdvaitaLabs/Setu.git && cd Setu
docker-compose -f docker/docker-compose.multi-validator.yml up -d

# 2️⃣  Submit a transfer between two agents
curl -X POST http://localhost:8080/api/v1/transfer \
  -H "Content-Type: application/json" \
  -d '{"from": "agent_alice", "to": "agent_bob", "amount": 100}'

# 3️⃣  Query balance — finalized in ~50ms
curl http://localhost:8080/api/v1/balance/agent_bob

Tip

✅ Work recorded · ✅ TEE-attested · ✅ Finalized in 50ms

_{Want more? See the full API reference or jump to Run Your Own Node.}

🛠 What You Can Build

🤖 Agent Work Tracker

Record every action an AI agent takes, with cryptographic proof of execution.

Build "git for AI agents" — append-only, verifiable, queryable. Any auditor can reconstruct what an agent did and prove nothing was tampered with.

_{🎯 Best for: AI audit trails, compliance, agent debugging}

🏆 Agent Reputation System

Let agents accumulate verified work history.

Other agents (or humans) can query: "Has this agent reliably completed similar tasks?" — get a cryptographically signed answer in milliseconds. Trust networks without central authorities.

_{🎯 Best for: Agent marketplaces, AI staffing, trust networks}

💸 Agent-to-Agent Payments

Settle micropayments between agents in ~50ms.

No gas auctions, no human approvals, no block-time waits. At 200K+ TPS, per-second pricing becomes realistic.

_{🎯 Best for: AI service marketplaces, agent economies}

🔗 Multi-Agent Coordination

When multiple agents collaborate, Setu records causal dependencies via VLC.

Reconstruct "who did what, when, and what depended on what." Critical for debugging multi-agent systems and assigning responsibility.

_{🎯 Best for: Multi-agent frameworks, swarm intelligence}

🛡 Verifiable AI Inference

Run inference inside a TEE (Nitro Enclave). Setu records the attestation.

Verify: "This output came from this model, this hardware, this input." Useful for AI auditing, compliance, adversarial-proof inference.

_{🎯 Best for: Regulated AI, medical AI, financial AI}

🧪 ...And More

Setu is a substrate. If your use case involves agents acting at scale with verifiable work, reach out.

📝 Open an issue · 💬 Join Discord

_{🎯 Best for: Your next idea}

🤔 Why Setu

🟧 Why not just put agent records on Ethereum / Solana?

AI agents act thousands of times per second. At Ethereum's 30 TPS and gas costs, a single agent doing routine work would saturate the chain and pay $1,000+/day in gas. Setu's 200K-300K TPS and no-gas design makes per-action recording realistic.

🟦 Why not just use a database?

Because the whole point is trustless verifiability. If an agent's reputation lives in a database, the database operator controls it. Setu lets the agent control its own work history, with the network providing tamper-evidence.

🟪 Why not use a centralized AI execution service?

Centralized services can lie about what they ran. Setu uses TEE attestation (AWS Nitro) so anyone can later verify: "this exact model ran on this exact hardware with this exact input." You don't trust us. You verify.

🟩 Is this a Layer 1? Layer 2?

Neither, exactly. Setu is a causally-driven distributed ledger — closer to a DAG-based consensus network than a traditional blockchain. It can settle to Bitcoin or Ethereum if you need finality on a public chain, but it doesn't need one to function.

🟨 Is Setu production-ready?

Setu is in active development. The core consensus, VLC, TEE execution, and HTTP API are working and benchmarked. Production mainnet is on the roadmap. Use the current code for testnets, research, and pre-production prototypes.

🏗 How Setu Works

Architecture

╔══════════════════════════════════════════════════════════════════════════════╗
║                              Setu Network                                    ║
╠═════════════════════════════════╦════════════════════════════════════════════╣
║         Validator Nodes         ║           Solver Nodes                     ║
║                                 ║                                            ║
║  ┌──────────────────────────┐   ║   ┌──────────────────────────┐             ║
║  │    ConsensusEngine       │   ║   │      TeeExecutor         │             ║
║  │  ┌────────┐ ┌─────────┐  │   ║   │                          │             ║
║  │  │  DAG   │ │   VLC   │  │   ║   │  ┌────────────────────┐  │             ║
║  │  └────────┘ └─────────┘  │   ║   │  │   EnclaveRuntime   │  │             ║
║  │  ┌────────────────────┐  │   ║   │  │  (Mock / Nitro)    │  │             ║
║  │  │  ValidatorSet      │  │   ║   │  └────────────────────┘  │             ║
║  │  │  (Leader Election) │  │   ║   │                          │             ║
║  │  └────────────────────┘  │   ║   └──────────────────────────┘             ║
║  │  ┌────────────────────┐  │   ║                                            ║
║  │  │   AnchorBuilder    │  │   ║   ┌──────────────────────────┐             ║
║  │  │  (Merkle Roots)    │  │   ║   │   SolverNetworkClient    │             ║
║  │  └────────────────────┘  │   ║   └──────────────────────────┘             ║
║  └──────────────────────────┘   ║                                            ║
║                                 ║                                            ║
║  ┌──────────────────────────┐   ║                                            ║
║  │  GlobalStateManager      │   ║                                            ║
║  │  (Sparse Merkle Trees)   │   ║                                            ║
║  └──────────────────────────┘   ║                                            ║
╠═════════════════════════════════╩════════════════════════════════════════════╣
║                          P2P Network (Anemo / QUIC)                          ║
╚══════════════════════════════════════════════════════════════════════════════╝

🔑 The 5 Core Innovations

🟢 Innovation	What it does	Why it matters
🌐 DAG-Based Consensus	DAG-BFT with leader rotation	High throughput without sacrificing finality
⏱ Vector Logical Clock	Causal ordering of distributed events	Agents act in parallel; ordering still verifiable
🛡 TEE Execution	Trusted Execution (AWS Nitro)	Verifiable AI inference, private data, attested output
🔀 Subnet Architecture _{in development}	Multi-subnet support	Horizontal scaling — each workload its own subnet
🌳 Merkle State Commitment	Binary + Sparse Merkle Trees	Light clients verify state without full sync

🔄 Consensus Flow

  ┌─────────┐    ┌───────────┐    ┌──────────┐    ┌──────────┐    ┌─────────┐
  │  Event  │ ─► │    TEE    │ ─► │ Verifier │ ─► │   DAG    │ ─► │  State  │
  │ Submit  │    │ Execution │    │  Adds to │    │ Folding  │    │ Commit  │
  └─────────┘    └───────────┘    │   DAG    │    │ (Anchor) │    └─────────┘
                                  └──────────┘    └──────────┘
       ▲                                                ▲
       │                                                │
   Agent / Client                                ConsensusFrame
                                              Quorum 2/3+1 voting

Key Concepts:

🟢 Event — Atomic state change with TEE attestation
🟡 Anchor — Checkpoint containing events + Merkle roots
🔵 ConsensusFrame (CF) — Voting unit for finalization
🟣 VLC — Vector Logical Clock for causal ordering

_{Deeper dive: docs/architecture.md}

📦 Get Started

🟢 Path 1 · Use Setu in your app

Tip

Most users start here. You don't need to run your own node.

# Submit a transfer
curl -X POST http://your-validator:8080/api/v1/transfer \
  -H "Content-Type: application/json" \
  -d '{"from": "alice", "to": "bob", "amount": 100}'

# Query balance
curl http://your-validator:8080/api/v1/balance/bob

# Query an object
curl http://your-validator:8080/api/v1/object/<object_id>

# List recent events
curl http://your-validator:8080/api/v1/events

Note

💡 Python / TypeScript / Go SDKs are on the roadmap. For now, any HTTP client works.

🟦 Path 2 · Run Your Own Node

📋 Prerequisites

Rust 1.75+ (2021 edition)
RocksDB for persistent storage
Docker for containerized deployment (optional)

🔨 Build from source

git clone https://github.com/AdvaitaLabs/Setu.git
cd Setu
cargo build --release
cargo test --all

⚙️ Run a Validator

export VALIDATOR_ID=validator-1
export VALIDATOR_HTTP_PORT=8080
export VALIDATOR_P2P_PORT=9000
export VALIDATOR_DB_PATH=/tmp/setu/validator

./target/release/setu-validator

🧮 Run a Solver

export SOLVER_ID=solver-1
export SOLVER_PORT=9001
export VALIDATOR_ADDRESS=127.0.0.1
export VALIDATOR_HTTP_PORT=8080

./target/release/setu-solver

💻 Submit Transactions via CLI

./target/release/setu balance --address <ADDRESS>
./target/release/setu transfer --from <FROM> --to <TO> --amount 1.23
# For raw smallest units, use: --amount-units 123000000

🐳 Docker Deployment (multi-validator)

cd docker
./scripts/build.sh
docker-compose -f docker-compose.multi-validator.yml up -d
docker-compose logs -f

📁 Project Structure

Click to expand the full project tree

Setu/
├── consensus/              # DAG-based consensus implementation
│   ├── dag.rs             # DAG data structure
│   ├── engine.rs          # Main consensus engine
│   ├── anchor_builder.rs  # Anchor creation with Merkle trees
│   ├── folder.rs          # ConsensusManager for CF management
│   └── vlc.rs             # VLC integration
│
├── types/                  # Core type definitions
│   ├── event.rs           # Event, EventId, EventStatus
│   ├── consensus.rs       # Anchor, ConsensusFrame, Vote
│   ├── object.rs          # Object model (Coin, Profile, etc.)
│   └── merkle.rs          # Merkle tree types
│
├── storage/                # Storage layer
│   ├── memory/            # In-memory implementations (DashMap)
│   ├── rocks/             # RocksDB persistent storage
│   └── state/             # GlobalStateManager, StateProvider
│
├── crates/
│   ├── setu-vlc/          # VLC Hybrid Logical Clock library
│   ├── setu-merkle/       # Merkle trees (Binary + Sparse)
│   ├── setu-keys/         # Cryptographic key management
│   ├── setu-enclave/      # TEE abstraction (Mock + Nitro)
│   ├── setu-network-anemo/# Anemo-based P2P network
│   ├── setu-transport/    # HTTP/WS/gRPC transport layer
│   ├── setu-protocol/     # Protocol message definitions
│   └── setu-core/         # Shared core utilities
│
├── setu-validator/         # Validator node binary
├── setu-solver/            # Solver node binary
├── setu-cli/               # CLI tool
├── setu-rpc/               # RPC layer
├── setu-benchmark/         # TPS benchmark tool
│
├── api/                    # HTTP API layer
├── docker/                 # Docker deployment configs
├── scripts/                # Deployment & test scripts
└── docs/                   # Design documents

⚙️ Configuration

🟢 Validator environment variables

Variable	Default	Description
`VALIDATOR_ID`	`validator-1`	Unique validator identifier
`VALIDATOR_HTTP_PORT`	`8080`	HTTP API port
`VALIDATOR_P2P_PORT`	`9000`	P2P network port
`VALIDATOR_DB_PATH`	(memory)	RocksDB path for persistence
`VALIDATOR_KEY_FILE`	—	Path to keypair file

🟦 Solver environment variables

Variable	Default	Description
`SOLVER_ID`	`solver-{uuid}`	Unique solver identifier
`SOLVER_PORT`	`9001`	Solver listen port
`SOLVER_CAPACITY`	`100`	Max concurrent tasks
`VALIDATOR_ADDRESS`	`127.0.0.1`	Validator address
`AUTO_REGISTER`	`true`	Auto-register on startup

🟣 Consensus configuration

Parameter	Default	Description
`vlc_delta_threshold`	`10`	VLC delta to trigger folding
`min_events_per_cf`	`1`	Minimum events per ConsensusFrame
`max_events_per_cf`	`1000`	Maximum events per ConsensusFrame
`vote_timeout_ms`	`5000`	Voting timeout in milliseconds

🔌 API Reference

HTTP Endpoints

Method	Endpoint	Description
	`/health`	Health check
	`/api/v1/transfer`	Submit transfer between agents
	`/api/v1/balance/{address}`	Query balance for an address
	`/api/v1/object/{id}`	Query an object by ID
	`/api/v1/events`	List recent events
	`/api/v1/register/solver`	Register a new solver

RPC Services

🟢 ConsensusService — Event submission, CF proposal, voting
🟦 SyncService — Event/CF synchronization between validators
🟣 DiscoveryService — Peer discovery and management

_{Full API docs: docs/api.md}

📊 Performance

Metric	Value	Notes
⚡ TPS		DAG-BFT consensus
⏱ Latency		End-to-end confirmation
🛡 Validators		BFT consensus quorum
🧮 Solvers		Horizontal scaling

Run Benchmarks Yourself

# Simple TPS test
python scripts/tps_test_simple.py

# Full benchmark
cargo bench --package setu-benchmark

🗺 Roadmap

🟢 Now `v0.x`

✅ DAG-BFT consensus
✅ VLC causal ordering
✅ TEE execution (Nitro + Mock)
✅ HTTP API + CLI
✅ Multi-validator Docker
✅ 200K+ TPS benchmark

🟡 Next `Q3 2026`

🔨 Subnet architecture
🔨 Python SDK
🔨 TypeScript SDK
🔨 LangChain integration
🔨 Public testnet launch

🔵 Later `Q4 2026+`

📋 MCP server integration
📋 Cross-chain bridges
📋 Reputation primitives
📋 Production mainnet
📋 ZK proof integration

Tip

💬 Want to influence the roadmap? Open an issue or join our Discord.

🤝 Community

_{Questions, help, dev chat}

_{Updates & announcements}

_{Full ecosystem site}

_{Deep technical docs}

Get Involved

Action	How
⭐ Star this repo	If Setu solves a problem you have
🐛 Open an issue	Bug reports, feature requests
🔧 Submit a PR	See Contributing Guidelines — start with `good-first-issue`
💬 Join the discussion	Discord — we read every message
🐦 Tweet about Setu	Tag @Hetu_Protocol

📈 Stargazers Over Time

👥 Contributors

_{Made with contrib.rocks}

📄 License

This project is licensed under the Apache License 2.0 — see LICENSE for details.

📖 Citation

If Setu helps your research, please cite it:

@software{setu2026,
  title  = {Setu: A Causally-Driven Distributed Ledger for AI Agent Economies},
  author = {{Advaita Labs}},
  year   = {2026},
  url    = {https://github.com/AdvaitaLabs/Setu}
}

 ┌─┐┌─┐┌┬┐┬ ┬
 └─┐├┤  │ │ │
 └─┘└─┘ ┴ └─┘

_{Built for the AI-native economy by Advaita Labs}

hetu.org · @Hetu_Protocol · Discord · Docs

_{⭐ Star us on GitHub · 🐦 Share on Twitter}

Name		Name	Last commit message	Last commit date
Latest commit History 496 Commits
.github/ISSUE_TEMPLATE		.github/ISSUE_TEMPLATE
api		api
config		config
consensus		consensus
crates		crates
deploy		deploy
docker		docker
docs		docs
examples/move		examples/move
scripts		scripts
setu-benchmark		setu-benchmark
setu-cli		setu-cli
setu-framework		setu-framework
setu-rpc		setu-rpc
setu-solver		setu-solver
setu-validator		setu-validator
storage		storage
tools/move-compile		tools/move-compile
types		types
.gitignore		.gitignore
Cargo.lock		Cargo.lock
Cargo.toml		Cargo.toml
LICENSE		LICENSE
README.md		README.md
genesis-multi.json		genesis-multi.json
genesis.json		genesis.json

Uh oh!

Folders and files

Latest commit

History

Repository files navigation

The ledger that ticks when AI agents work — not when miners do.

⚡ What is Setu

🔐 Prove work was done

💸 Get paid by other agents

🏆 Build verifiable reputation

🔗 Coordinate without trust