forge docs

Sigil integration

Pin Forge agents to a Sigil chain — verifiable execution, on-chain identity, x402 settlement.

Sigil integration

Sigil is L1fe's blockchain and P2P infrastructure. Forge agents can be pinned to a Sigil chain to gain:

  • On-chain identity — agent DIDs anchored as Sigil entities
  • Verifiable execution — run history rolled up into ZK proofs (Jolt Pro)
  • Generation decay rewards — agents earn from their lineage's productive work
  • x402 micropayments — per-call settlement using forge-agent402

This page describes the bridge surface. Implementation lives in the arise-bridge crates inside the Sigil repo.

Pinning an agent

use forge::sigil::{SigilClient, pin_agent};

let sigil = SigilClient::connect("https://rpc.sigil.network").await?;
let receipt = pin_agent(&sigil, &agent.identity()).await?;
println!("agent pinned: tx={}, block={}", receipt.tx_hash, receipt.block);

The agent's DID is now a first-class Sigil entity. Every execution receipt the agent produces can be anchored to this DID, and every reward distribution in its lineage flows here.

x402 micropayments

forge-agent402 adds an x402 wallet to any agent:

use forge::agent402::AgentWallet;

let wallet = AgentWallet::new(&agent.identity(), &sigil_keypair);
let agent = StreamingToolLoopAgent::new(/* ... */)
    .with_wallet(wallet);

When the agent calls a tool that requires payment (e.g., a paid API), the bridge:

  1. Receives a 402 from the upstream
  2. Constructs an x402 payment for the requested amount
  3. Signs with the agent's Sigil keypair
  4. Retries the tool call with the payment header
  5. Records the payment as part of the ToolInvocationRecord

Generation decay rewards

Sigil's economics distribute rewards along agent lineage with generation decay — each step away from the human root reduces the share. This means:

  • Humans earn the highest rate
  • Direct agent children earn less
  • Tool-calls and grand-children earn proportionally less still

Forge surfaces lineage in ForgeAgentIdentity::lineage_generation() so you can predict reward shares before pinning.

Verifiable execution

For high-trust workloads, agents can produce ZK execution receipts:

use forge::sigil::ProveExecution;

let receipt = ProveExecution::new(&agent)
    .prove(&output)
    .await?;
sigil.submit_receipt(&receipt).await?;

The receipt commits to:

  • The agent's DID
  • The input prompt hash
  • The full tool-invocation log hash
  • The final output hash
  • The model used

Anyone with the receipt can verify these without re-running the agent.

Status

The bridge surface is planned. The Sigil chain itself is live; the arise-bridge crates are the integration point. Tracking the public shape of these helpers happens in the Sigil repo's bridge milestone.

Next