PROOF Autonomous pause + slash, settled on Arc

Credit rails for autonomous market agents.

Forum turns USDC deposits into mandate-bounded credit lines. Operators get execution rights, not custody. Every cycle publishes a recomputable receipt, and any third party can pause the vault and slash the bond — in a single transaction — when the mandate breaks.

Open console Integrate an agent View source ↗

TVL — Receipts — Latest publish — Agents —

Built for Agora Agents Hackathon · Canteen × Circle × Arc · May 11–25 2026 · Now on Arc mainnet · chain 5042

Live on Arc mainnet

TrackRecordV2 · Forum keeper

streaming

Receipts committed

Vault state

Keeper Covenant Account (V3)

—

Agents indexed

TrackRecordV2 · mainnet

—

Latest publish

Keeper heartbeat

—

Arc finality

Sub-second BFT

~700ms

Every value above is read live from Arc mainnet (chain 5042).

Built on

Arcmainnet · 5042 Circle USDCnative Polymarket V2verified fill · May 2026 EIP-712signed receipts RiskKernelV2permissionless enforce SlashBondoperator collateral

Active agents

indexer

Registered on TrackRecordV2

Receipts published

on-chain

Recomputable · EIP-712 signed

Latest publish

live

Keeper heartbeat

Arc block

chain 5042

Sub-second BFT finality

The gap

Capital can't trust an AI agent today.

Hand over a private key and the operator runs everything. Onboard through a regulated managed account and you're back to KYC, custody, and multi-day setup — incompatible with bots that act in milliseconds. Every team that wants this pattern rebuilds the same mandate enforcement, drawdown gates, and slash-on-breach plumbing from scratch.

So capital sits out, and every "12% APY market-maker" pitch stays unverifiable.

Forum's primitive

A mandate-bounded credit line on Arc.

One contract holds depositor USDC. The operator gets execution rights bounded by an on-chain mandate: max budget, max drawdown, receipt freshness, expiry, perf-fee cut, slash bond. The operator never custodies funds.

Anyone can call RiskKernelV2.enforce(vault). A single transaction flips the vault to PAUSED and slashes the bond. No admin signer, no fallback path.

Built for

One credit network. Three sides.

Agent builders

Ship a bot, not a wallet.

Open a mandate-bounded credit line in one transaction. Your bot pulls capped USDC, trades, returns funds, publishes a signed receipt each cycle. Allocators can fire you. They cannot drain you.

Launch a Covenant Account

Capital allocators

Underwrite agents, not keys.

AgentScore ranks every bot by drawdown, freshness, slash history, and streak length. Receipts are recomputable. Depositor withdrawals work in any state — no admin signer can override them.

Browse the leaderboard

Venues & operators

Prove fills without exposing keys.

Venue credentials and trade submission stay operator-side. Forum publishes fills, builder attribution, and receipt hashes so allocators can verify the result without a public trade button.

Verify the proof

How it works

Three contracts. One credit line.

Step 01

Deposit USDC

Anyone calls CovenantVault.deposit(amount). Funds sit idle until the operator pulls credit — bounded by the mandate.

depositors → vault.deposit()

Step 02

Operator pulls bounded credit

The bot calls pullCredit(N), capped at budgetUsdc. Trades on Polymarket V2 with the builder code. Returns capital and publishes a signed receipt each cycle.

operator → pullCredit() → trade → return

Step 03

Anyone enforces the mandate

Drawdown over limit. Receipt stale. Budget breach. Any third party calls RiskKernelV2.enforce(vault) — the vault flips to PAUSED and the bond is slashed in one transaction.

anyone → kernel.enforce() → pause + slash

Proof · Arc testnet, May 2026 · the transaction, not a screenshot

First autonomous slash, settled on-chain.

AgoraMind keeper missed its 30-minute receipt window. Any third party could then call RiskKernelV2.enforce(vault). Here is the transaction that did — on the Arc testnet deployment of RiskKernelV2 (May 2026). The contract is now live on Arc mainnet.

loading…

Result

ACTIVE → PAUSED + slashed

Verdict

PAUSE_STALE

Gas used

162,960

Bond slashed

1.25 USDC

Trigger

organic · no choreography

Reproduce locally

show advanced commands

# 1. clone
git clone github.com/Ridwannurudeen/forum
cd forum

# 2. fund operator + bond
node keeper/scripts/seed-tvl-and-bond.mjs

# 3. trigger violation (when in stale window)
node keeper/scripts/demo-violation.mjs

What this proves

✓ Mandate breach detection is permissionless — any third party can audit + enforce.
✓ Pause + slash happen atomically. No operator window to front-run withdrawals.
✓ Slashed funds flow to the bond's recipient (configurable — depositors, treasury, charity).
✓ Receipt hashes are recomputable and checked against the on-chain evidence hash.

Phase 3 · real fill, verified · May 2026

First real Polymarket V2 fill landed on the receipt graph.

$2 atomic FOK BUY on the TX-04 House-seat YES token. Settled on Polygon mainnet. Receipt anchored to TrackRecordV2 on Arc testnet (the mainnet TrackRecordV2 went live 2026-10-14). verifyReceipt() returns pnl: valid.

Polymarket settlement

marketTX-04 R win (YES)

filled2.32558 shares @ $0.86

paid2.011198 pUSD

typeFOK · POLY_1271

+ builder-attributed fill

code0x31bc0f22…ec56

attributionconfirmed ✓

fee rate0 bps (set on /settings?tab=builder)

Polygon settlement tx ↗

Forum receipt

botId0x75d6577d…0ef0

verifiedFillCount1

verifiedPnlrecomputed-from-fills

score (v0/v1)80 / 70

receipt JSON ↗ Arc publish tx (testnet) ↗ /api/proof ↗

Reproduce: node keeper/scripts/poly-create-api-key.mjs --confirm · then poly-live-test-local.mjs --broadcast · then poly-publish-real-fill-receipt.mjs. Full bytes32 trail in docs/phase-3-live-fill-proof.md.

Live mandate · CovenantVaultV3

Forum keeper credit line, on chain.

…

Budget

—

Max drawdown

—

Receipt freshness

—

Perf fee

—

TVL

—

Idle

—

Operator outstanding

—

SlashBond balance

—

Console · live on Arc mainnet

Agent operations, visible on-chain.

The keeper runs the strategy loop off-UI. The console shows the evidence: vault custody, adapter status, receipts, risk verdicts, and the few actions allocators actually need.

Wallet

not connected

mainnet · real funds

Live Claude trace

Latest decision trace of the Forum keeper (AgoraMind, mainnet).

Keeper Covenant Account

The CovenantVaultV3 the keeper draws bounded credit from — funded, slashable.

Router allocation

CapitalRouter: allocator pool targeting multiple Covenant Accounts.

Keeper loop · hidden action, public evidence

Funds stay in the vault. The operator draws bounded credit, never custody.

The keeper runs agora-mind-keeper.mjs off-UI. Users inspect custody, receipts, and risk state instead of pressing a deploy-funds button.

keeper script

Keeper

block -

V3 vault assets

idle / outstanding -

RiskKernelV2

state -

Operator bond

SlashBond · slashable by RiskKernelV2

Latest keeper receipt

Waiting for the indexed keeper bot.

Self-serve vaults

Covenant Accounts created by anyone through CovenantVaultFactoryV2, separate from the keeper's own vault.

What is intentionally not a button

Credit pulls

The keeper decides and calls pullCredit inside the mandate. Users inspect receipts and risk state.

Polymarket order execution

Operator-gated by venue credentials and geofencing. Public UI stays read-only.

Fee/router/risk-market admin

Those remain proof primitives and docs, not the default allocator path.

Fund vault Inspect agents

AgentScore v1 · ranked by drawdown / slash / freshness

Click any row for the inspector + one-click enforce per linked vault.

live · /api/agents

Bot ID	Kind	Score	Records	DD bps	Slashes	Last publish
loading...

v1 score extends the v0 freshness/drawdown/slash formula with per-vault bond attribution, uninterrupted streaks, mandate drift, exposure-change, and verified-fill signals. Source in keeper/scripts/forum-indexer.mjs.

Architecture · Arc mainnet · bytecode verified on Sourcify

The Arc mainnet contract set —

TrackRecordV2 ↗

Recomputable receipts

Anyone can verify the receipt hash in 60 seconds.

Browse live receipts →

Every TrackRecordV2 record commits to an evidenceUri + evidenceHash. The URI serves canonical JSON: order-book snapshots, fills, inventory, PnL inputs, strategy config hash, decision-trace hash.

Download the JSON, keccak256 it, compare to the on-chain hash. If they match, the operator's claim is signer-attributable, sequence-protected, replay-rejected, and time-monotonic — all enforced in the contract.

Reference verifier: keeper/src/receipt.ts and keeper/scripts/verify-receipt.mjs.

Live receipt check

Checking the keeper's latest mainnet receipt...

seq: -

computed: -

on-chain: -

Contract guarantees

▸ Strict sequence — seq = lastSeq + 1
▸ Monotonic time — periodEnd ≥ periodStart > lastPeriodEnd
▸ Hash chain — prevRecordHash matches stored
▸ Replay rejection — digest cannot be re-used
▸ EIP-712 signed — signer ∈ botSigner

Verify any receipt — in-browser

Paste a receipt URL, see the verification result inline.

no wallet, no server, no installs — same logic as keeper/src/receipt.ts

paste a receipt URL above — checked against TrackRecordV2 on Arc mainnet. The keeper's receipts live under /receipts/…/.

Developers · SDKs + verifier

Same primitives. Three runtimes.

TypeScript and Python clients wrap every contract. The verifier recomputes receipt hashes from the published JSON and checks them against TrackRecordV2 on-chain. No trusted relayer in the loop.

TypeScript · sdk-ts/ Python · sdk-py/ Arc Starter Kit ↗ GitHub ↗

sdk-ts/examples/open-covenant.ts v0.3 · install from sdk-ts/ source

// 1. install from source (not yet on npm)
//    git clone github.com/Ridwannurudeen/forum
//    cd forum/sdk-ts && npm install && npm run build

import { createPublicClient, defineChain, http, zeroAddress } from "viem";
import { ForumClient } from "forum-arc-sdk";

// Arc mainnet, passed explicitly (the SDK's bundled ARC_TESTNET / ARC_TESTNET_DEPLOYMENT exports are the testnet ones)
const arc = defineChain({
  id: 5042, name: "Arc",
  nativeCurrency: { name: "USDC", symbol: "USDC", decimals: 18 },
  rpcUrls: { default: { http: ["https://rpc.mainnet.arc.io"] } },
});
const publicClient = createPublicClient({ chain: arc, transport: http() });

// 2. point the client at the mainnet contracts (deployments/arc-mainnet.json)
const forum = new ForumClient({ publicClient, addresses: {
  registry: zeroAddress, config: zeroAddress,          // testnet-only v1 modules,
  trackRecord: zeroAddress, feeDistributor: zeroAddress, // not deployed on mainnet
  trackRecordV2:        "…",
  covenantVaultFactory: "…",
  covenantVault:        "…",   // the keeper's vault
  riskKernel:           "…",
} });

// 3. read live state · anyone can call this
const snapshot = await forum.covenantVault.snapshot();
const verdict  = await forum.riskKernel.evaluate();   // defaults to addresses.covenantVault
const vaults   = await forum.covenantVaultFactory.allVaults();
// → snapshot.state "ACTIVE", verdict "ALLOW"
// Opening your own vault (bond-gated) is the Create tab of the console.

sdk_py/examples/open_covenant.py v0.3 · install from sdk-py/ source

# 1. install from source (not yet on PyPI)
#    git clone github.com/Ridwannurudeen/forum
#    pip install -e forum/sdk-py  # plus web3

from web3 import Web3
from forum_arc import ForumClient, ForumAddresses

# Arc mainnet (chain 5042), passed explicitly — the bundled ARC_TESTNET constant is the testnet one
w3 = Web3(Web3.HTTPProvider("https://rpc.mainnet.arc.io"))
ZERO = "0x0000000000000000000000000000000000000000"  # testnet-only v1 modules, not deployed on mainnet
addresses = ForumAddresses(
    registry=ZERO, config=ZERO, track_record=ZERO, fee_distributor=ZERO,
    track_record_v2="…",
    covenant_vault_factory="…",
    covenant_vault="…",  # the keeper's vault
    risk_kernel="…",
)
forum = ForumClient(w3, addresses)

# 2. read live state · anyone can call this
snap = forum.covenant_vault.snapshot()
verdict = forum.risk_kernel.evaluate(addresses.covenant_vault)
vaults = forum.covenant_vault_factory.all_vaults()
print(snap.state, verdict, len(vaults))

src/RiskKernelV2.sol · enforce(vault) mainnet deploy pending

// Permissionless: any third party can call this.
// Single tx flips vault to PAUSED *and* slashes 25% of the operator bond
// on operator-fault verdicts. No admin signer. No fallback.

function enforce(address vault) external {
    Verdict v = evaluate(vault);
    if (v == Verdict.ALLOW) revert NoViolation();

    CovenantVault(vault).pause(uint8(v));
    emit EnforcementTriggered(vault, v, msg.sender);

    // Skip slash on PAUSE_EXPIRED — that's timeout, not fault
    if (v == Verdict.PAUSE_EXPIRED) return;

    _trySlash(vault, v);
}

function _trySlash(address vault, Verdict v) internal {
    address bond = bondOf[vault];
    uint256 bal  = SlashBond(bond).bondBalance();
    uint256 amt  = (bal * SLASH_BPS) / 10_000;  // 25%
    try SlashBond(bond).slash(amt, uint8(v)) {
        emit SlashTriggered(vault, bond, amt, v);
    } catch { /* bond drained or paused; pause still landed */ }
}

keeper/scripts/verify-receipt.mjs node ≥ 20 · zero deps beyond viem

# 1. download any receipt JSON from /receipts/<botId12>/<seq>.json
$ curl -sO https://forum.gudman.xyz/receipts/201c8909dca1/000071.json

# 2. recompute the hash; pass the evidenceHash read from TrackRecordV2 on Arc mainnet to compare
$ node keeper/scripts/verify-receipt.mjs 000071.json

  receipt seq        71
  evidenceHash       0x30bc2a76…ab9952
  on-chain hash      0x30bc2a76…ab9952
  hash match         ✓
  pnl recompute      valid (3 fills, realized +0 USDC, unrealized +0 USDC)
  signer ∈ botSigner ✓
  sequence ok        seq = lastSeq + 1
  monotonic time     ✓ (periodEnd > lastPeriodEnd)

  RECEIPT VERIFIED

Security & honesty

Hackathon-grade. Here is exactly where.

Every claim on this page is verifiable on Arc. Every gap is in this section. Capital should walk in knowing both.

Shipped

✓ Immutable contracts on Arc mainnet — all 8 modules live and Sourcify-verified (exact match), no proxy, no upgradeability
✓ Permissionless enforce(vault) · autonomous pause + slash proven on Arc testnet, May 2026
✓ EIP-712 receipts: strict sequence, hash chain, replay rejection, monotonic time
✓ Depositor withdraw works in any state · operator cannot trap depositors
✓ CovenantVaultFactory · permissionless self-serve vault creation

Caveats we won't hide

! No third-party audit yet — mainnet is a capped pilot with real funds. Deposit only what you can afford to lose.
! No on-chain venue allow-list yet — operator can route pulled USDC to any wired venue.
! Receipt PnL recomputation is per-fill where data exists; full unrealised PnL is in progress.
! Live AgoraMind keeper runs paper-mode by default. Vault-USDC→Polymarket pUSD automation and real fee capture are on the roadmap.
! Bug bounty intake via GitHub Issues. Formal program will open after audit.

Test coverage

Foundry (Solidity) passing

Keeper (Vitest) passing

TS SDK typecheck pass

Python SDK import pass

GitHub Actions green ↗

We tested it on ourselves

Forum's own v1 bot fails. That is the point.

docs/backtest-notes.md ↗

Bad strategies self-disqualify on chain in 30 minutes — stale receipt, drawdown breach, oversubscription — and the same transaction slashes the operator bond. Good strategies prove themselves with signed, recomputable receipts. Allocators decide on cryptographic evidence, not Sharpe screenshots.

Our v1 keeper is a naive Avellaneda-Stoikov market maker on 16 Polymarket V2 books: 57 fills over 7 days, mean Sharpe −5.05, total PnL −$77.93. Exactly what the literature predicts for an MM without maker rebates or microstructure tuning — and exactly the kind of strategy Forum is designed to surface, contain, and replace.

Reproduce locally: node keeper/scripts/pull-prices.mjs --markets 20 --days 7 --fidelity 1 then tsx scripts/run-backtest.mjs.

total fills 57

mean Sharpe −5.05

total PnL −$77.93

sum max DD $81.32

7-day window · 16 markets

Live on Arc · permissionless

Open your first Covenant Account. Two signatures. No admin signer. A bond you own.

Connect a wallet. Set a mandate. Sign two transactions — one deploys a SlashBond you own, one creates the immutable vault wired to it, with RiskKernelV2 enforcement.

Launch the console View source on GitHub