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 · Chain 5042002

Live on Arc testnet

CovenantVaultV1.2 · AgoraMind

streaming

Receipts committed

Vault state

Mandate-bounded credit line

—

Agents indexed

TrackRecord v1 + v2

—

Latest publish

Keeper heartbeat

—

Arc finality

Sub-second BFT

~700ms

Every value above is read live from testnet.arcscan.app.

Built on

Arctestnet · 5042002 Circle USDCnative Polymarket V2live fill EIP-712signed receipts RiskKernelV2permissionless enforce SlashBondv1.1

Active agents

indexer

Registered on TrackRecord

Receipts published

on-chain

Recomputable · EIP-712 signed

Latest publish

live

Keeper heartbeat

Arc block

chain 5042002

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

Live proof on Arc · 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.

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

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 published to TrackRecordV2 on Arc. 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 ↗ /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 · CovenantVaultV1.2

AgoraMind credit line, on chain right now.

…

Budget

200 USDC

Max drawdown

5.00%

Receipt freshness

30 min

Perf fee

20% > HWM

TVL

—

Idle

—

Operator outstanding

—

SlashBond balance

—

Console · live on Arc testnet

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

Get testnet USDC ↗

Live Claude trace

Latest AgoraMind decision trace, not the old mock policy.

Real-fill Covenant Account

Polymarket receipt bot bound to a funded, slashable Arc vault.

Router allocation

Allocator pool targets multiple Covenant Accounts.

Keeper loop · hidden action, public evidence

Funds move vault to adapter, not operator wallet.

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

keeper script

Keeper

block -

V2 vault assets

idle / strategy -

RiskKernelV3

state -

Yield venue

Idle adapter

USYC entitlement pending

Latest strategy receipt

Waiting for indexed strategy bot.

External user proof

Shows the user-created funded vault separately from the deployer-operated AgoraMind vault.

What is intentionally not a button

Strategy deployment

The keeper decides and calls deployToStrategy. 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 · all bytecode verifiable on testnet.arcscan.app

The live Arc contract set 15 deployed modules · 5 core surfaces shown first

factory ↗

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 latest AgoraMind 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 — defaults to the D74 phase-3 fill.

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, createWalletClient, custom, http } from "viem";
import { ForumClient } from "forum-arc-sdk";
import { ARC_TESTNET_DEPLOYMENT, ARC_TESTNET } from "forum-arc-sdk/deployments";

const publicClient = createPublicClient({ chain: ARC_TESTNET, transport: http() });
const walletClient = createWalletClient({ chain: ARC_TESTNET, transport: custom(window.ethereum) });

const forum = new ForumClient({ publicClient, walletClient, addresses: ARC_TESTNET_DEPLOYMENT });

// 2. open a mandate-bounded credit line
const { vault } = await forum.factory.createVault({
  operator,
  botLabel:           "my-poly-mm-v1",
  budgetUsdc:         200n,
  maxDrawdownBps:     500,        // 5%
  receiptFreshnessSec: 1800,       // 30 min
  perfFeeBps:         2000,       // 20% > HWM
});

// 3. read live state · anyone can call this
const snapshot = await forum.covenantVault(vault).snapshot();
const verdict  = await forum.riskKernel.evaluate(vault);
// → { state: "ACTIVE", verdict: "ALLOW", outstanding: 0n, idle: 1_000_000n }

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
from forum_arc.deployments import ARC_TESTNET_DEPLOYMENT

w3 = Web3(Web3.HTTPProvider("https://rpc.testnet.arc.network"))
forum = ForumClient(w3, ARC_TESTNET_DEPLOYMENT, acct)

# 2. open a mandate-bounded credit line
vault = forum.factory.create_vault(
    operator=operator,
    bot_label="my-poly-mm-v1",
    budget_usdc=200,
    max_drawdown_bps=500,         # 5%
    receipt_freshness_sec=1800,    # 30 min
    perf_fee_bps=2000,            # 20% > HWM
)

# 3. read live state
snap = forum.covenant_vault(vault).snapshot()
verdict = forum.risk_kernel.evaluate(vault)
print(snap.state, verdict)
# → State.ACTIVE Verdict.ALLOW

src/RiskKernelV2.sol · enforce(vault) live · 0x0af356f2…feec4055

// 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. run the verifier against the live TrackRecordV2 contract on Arc
$ 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 testnet (15 modules, no proxy, no upgradeability)
✓ Permissionless enforce(vault) · live pause + slash demoed
✓ 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 — testnet / demo capital only.
! 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