DEVNET LIVE

The AI-native
blockchain.

Layer-1 designed from first principles for autonomous agents, verifiable training, and high-throughput execution.

Start Building Download Client
Deterministic AI Execution
Proof-of-Training (PoT) Primitive
Native Ark Language

Built for an
autonomous future.

Arknet treats AI, compute, and capital as first-class citizens. Models are deployed as contracts, training is proven on-chain.

Native Intelligence

Models, weights and training proofs are part of consensus, not an afterthought.

Deterministic Run

A contract call yields the same result on every node — even for complex AI flows.

Production Grade

Parallelized execution and compact proofs let apps scale without giving up safety.

The new primitives.

Proof-of-Training (PoT)

Verifiable training, on-chain. Arknet introduces PoT as a canonical state object. Training runs emit proofs your contracts can verify directly, turning 'trust me, I trained this' into a programmable guarantee.

Contract Engine for Agents

Smart contracts on Arknet are designed to host autonomous agents. Model inference, policy evaluation, and settlement happen in one atomic environment with storage abstraction for long-lived agent state.

Deterministic, Programmable State

State that matches the math. Arknet's state layer uses overlays, Merkle commits, and validator roots to make every transition auditable and efficient.

From training to trust.

Nothing is hidden. Training, deployment, and inference are all cryptographic events anchored on the ArkNet ledger.

PHASE 01

Define

Create the model architecture and training constraints on-chain via a Model Definition Contract.

PHASE 02

Train

Compute providers execute training. Zero-knowledge Proof-of-Training (PoT) is generated in real-time.

PHASE 03

Anchor

PoT is verified by ArkNet validators. Model weights are merkle-ized and anchored to the AI Chain.

PHASE 04

Infer

Agents call the model contract. Inference is executed deterministically with 1.01s finality.

Built for builders.

Meet Ark. A domain-specific language designed for safe AI orchestration and asset management.

No pointers, no undefined behavior. Just clean, predictable state transitions that handle tokens and tensors with equal ease.

First-class 'state' primitives
Built-in storage table abstraction
Native AI quote & inference hooks
Read Ark Docs 
state AiRouterState {
  default_model:    u64;   // e.g. 1 = "ark/llm-v1"
  max_price_planck: u64;   // per-call cap
  pay_from_payor:   bool;  // true -> debit tx.payor
}

module AiRouter {
  state: AiRouterState;

  public fn init(default_model: u64, cap: u64) {
    state.default_model    = default_model;
    state.max_price_planck = cap;
    return;
  }

  // Main entry: route prompt to the LLM.
  public fn infer(prompt: str) -> u64 {
    let model = state.default_model;
    let cap   = state.max_price_planck;

    // 1. Ask for a quote (builtin -> ARK_IMP_AI_QUOTE)
    let q = ai_quote(model, prompt);
    require(q <= cap, "ai: quote above cap");

    // 2. Pay and run the model.
    // ai_call_pay charges account & runs verification
    let paid = ai_call_pay(model, prompt, cap);

    return paid;
  }
}