Infrastructure for the machine economy.
Conductra is a Layer-1 shaped for autonomous agents, high-frequency coordination, and programmable settlement. Rust handles orchestration and protocol logic. C++ is reserved for hot-path kernels where latency actually matters.
Identity layer
01DID-compatible registry for agent-native coordination.
Consensus outcomes
02Fast slots and weighted validation for predictable finality.
Execution engine
03Parallel scheduling and sandboxed WASM execution paths.
Programmable settlement
04Channels and proofs for machine-speed payment flows.
Runtime
WebAssembly contracts
State
Merkle-backed storage
Protocol target
~50,000
Sustained TPS Target
Protocol target
500 ms
Slot Duration Target
Protocol target
~2–3 sec
Finality Target
Protocol target
200–400
Validator Set Target
Protocol layers
Modular surfaces for execution, settlement, and proof.
The repo already reads like a layered system. The site should too: a protocol built around identity, consensus, execution, payments, and verifiable state transitions.
DID-compatible registry
Identity
Agent identities are designed to be first-class protocol objects, giving autonomous systems a durable coordination surface from the start.
RepuICN outcomes
Consensus
Reputation-weighted validation is framed around faster slots, predictable finality, and network behavior tuned for machine-speed coordination.
Parallel + WASM
Execution
Access lists, conflict detection, and a sandboxed WebAssembly runtime create a deterministic execution path without a single-threaded bottleneck.
Priority-aware throughput
Mempool + Fees
Priority scoring, gas accounting, and a dynamic base fee model let the network adapt to load without losing clarity for developers.
Intent-based settlement
Payment Channels
Streaming micropayments and state channels reduce base-layer friction for high-frequency machine-to-machine flows.
Verifiable execution
ZK Validation
The protocol is shaped for proof-backed workflows where off-chain execution can still be settled with strong verification guarantees.
Why this exists
Built for the kinds of transaction patterns legacy chains never targeted.
Conductra is positioned for software systems that need to coordinate repeatedly, settle frequently, and still preserve deterministic execution guarantees.
Autonomous agent coordination
01Identity, intent channels, and fast finality fit workflows where software systems negotiate, transact, and settle without manual checkpoints.
High-frequency machine payments
02Micropayment streams and off-chain channel updates make repeated low-value interactions practical for services, devices, and compute markets.
Verifiable compute pipelines
03Parallel execution and proof-oriented architecture create a credible path for systems that need both speed and auditability.
Developer surface
The repo already exposes the right entry points. The website should surface them quickly.
Conductra ships with a TypeScript SDK, Python tooling, a C FFI boundary, and an RPC/WebSocket server in the monorepo. Developers should not need to read Rust before they understand the shape of the system.
Quick start
import { ConductraClient } from "@conductra/sdk";const client = new ConductraClient("http://localhost:9944");const health = await client.health();const balance = await client.getBalance("aabb...0032bytehexaddress");console.log(health.status);console.log(balance.balance, balance.nonce);@conductra/sdk
TypeScript SDK
Use ConductraClient, transaction builders, signing helpers, and WebSocket subscriptions against a local or remote node.
conductra-py
Python Client
Script node interactions and notebook workflows without dropping into Rust internals.
mobile / JNI / cgo
C FFI
Bridge protocol functionality into native environments where a C ABI is the most practical boundary.
crates/conductra-rpc
HTTP + WebSocket RPC
Health, balances, transactions, channels, checkpoints, and subscriptions are all exposed through a single developer-facing surface.
Start here
Read the protocol. Use the SDK. Judge the repo on the details.
Conductra is an engineering-led protocol story. The site is meant to help visitors understand that quickly, then move them straight into the codebase.