The Coordination Layer for Intelligent Systems

Tashi is the missing infrastructure primitive real-time, leaderless consensus at the edge. Where robots, AI agents, and autonomous systems coordinate across trust boundaries without centralized control.

Start Building → Read Whitepaper

Vertex

The consensus engine at the core of Tashi. A DAG-based protocol that reaches Byzantine fault-tolerant agreement in under 100 milliseconds with no leaders, no vote messages, and no gas fees.

Gossip-about-Gossip

Peers exchange signed events referencing previous events, building a causally-ordered DAG asynchronously.

Virtual Voting

No votes are transmitted. Consensus is mathematically derived from the DAG structure, eliminating a full network round.

Fair Ordering

Events ordered by collective witness, not leader selection. Prevents front-running and provides censorship resistance.

Cryptographic Proofs

Every consensus round produces a multi-signed Proof of Coordination. Verifiable by anyone, anywhere.

26ms Consensus latency with 8 peers

1.026M Transactions per second

⌊n/3⌋ Byzantine fault tolerance

$0 Per-transaction gas fees

What Will You Coordinate?

Robotics

Cross-operator coordination for warehouse AMRs, delivery drones, and autonomous vehicles. No single vendor controls the network.

Sub-100ms collision avoidance across trust boundaries

AI Agents

Millisecond discovery and Byzantine-robust consensus for distributed inference, federated learning, and multi-agent negotiation.

Byzantine-robust aggregation prevents data poisoning

Industrial IoT

Cross-boundary sensor coordination for smart cities, manufacturing, and energy grids. Private by default - only proofs leave the network.

Privacy-preserving decentralized agreement

Gaming

Serverless multiplayer with fair ordering that prevents front-running. Reduce infrastructure costs by 50%+ with peer-to-peer consensus.

~26ms latency proven in production

What will you build?

Any system where independent machines need to agree - fast, fair, and without a central authority.

Explore the SDK →

Start Building in Minutes

Vertex ships as a native library with Rust and C bindings. Add consensus to your application with a single dependency.

Terminal

# Add Vertex to your project
cargo add tashi-vertex

src/main.rsRust

use tashi_vertex::{
    Context, Engine, KeySecret,
    Message, Options, Peers,
    Socket, Transaction,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let key: KeySecret = "BASE58_SECRET".parse()?;

    // Configure the network
    let mut peers = Peers::new()?;
    peers.insert(
        "10.0.1.2:9001",
        &"PEER_PUBLIC_KEY".parse()?,
        Default::default(),
    )?;

    // Start consensus
    let ctx = Context::new()?;
    let socket = Socket::bind(&ctx, "0.0.0.0:9000").await?;
    let engine = Engine::start(
        &ctx, socket, Options::default(),
        &key, peers,
    )?;

    // That's it - you have BFT consensus
    engine.send_transaction(tx)?;
}