The autonomous agent

Claros is not just a set of contracts, it is an autonomous operator that runs them. A DeepSeek tool-calling agent wakes on a fixed heartbeat, decides what to do, and acts through a small set of tools that read public data and sign Casper transactions. No human approves any step: the agent clears a zero-knowledge compliance gate, attests fresh real-world data on-chain, then decides whether to put idle treasury to work in a yield venue and records that decision on-chain.

The agent has two layers:

The heartbeat: run only on new data

The heartbeat (agent/src/loop.ts) is deliberately dumb. It wakes on an interval, asks the upstream source for the latest reporting period, and starts a full cycle only when that period is strictly newer than the last one it processed. Re-attesting an unchanged period would write an identical record and waste gas, so the agent deduplicates by period and keeps the last processed period per asset in a small state file.

async function tick() {
  const state = loadState();                  // { "OP-1": 20260622, ... }
  for (const asset of ASSETS) {
    const { period } = await latestRevenue(asset);
    const last = state[asset];
    if (last && period <= last) continue;      // no new data: skip, spend no gas
    if (!DRY_RUN) await runCycle(asset);       // a full autonomous cycle
    state[asset] = period;
    saveState(state);
  }
}
 
await tick();                                  // run once on startup
setInterval(tick, INTERVAL_MS);                // then every INTERVAL_MS (default 1 hour)

The heartbeat is configured entirely through the environment, so an operator can point it at different assets, change the cadence, or rehearse without writing anything.

The cycle

When the heartbeat sees new data it calls runCycle(asset) (agent/src/agent-cycle.ts). This is a standard tool-calling loop against an OpenAI-compatible DeepSeek endpoint (model deepseek-chat). The agent is seeded with a system policy and a single user turn (Run one autonomous cycle for asset "<asset>". Decide and act.), then it loops: the model returns either a message or one or more tool calls, each tool call is dispatched to the matching function in tools.ts, and the JSON result is fed back as a tool message. The loop runs until the model stops calling tools, up to 14 steps.

for (let step = 0; step < 14; step++) {
  const res = await client.chat.completions.create({
    model: MODEL,                  // deepseek-chat
    messages,
    tools: toolSchemas,
    tool_choice: 'auto',
  });
  const msg = res.choices[0].message;
  messages.push(msg);
  if (!msg.tool_calls?.length) break;          // model is done
  for (const tc of msg.tool_calls) {
    const result = await dispatch[tc.function.name](JSON.parse(tc.function.arguments || '{}'));
    messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify(result) });
  }
}

The system policy instructs the model to treat tool outputs as ground truth and to act in a fixed order. One cycle proceeds through these stages.

The tools it has

The model can only act through the tools wired into the cycle. Six are read-only and inform the model’s decisions, three sign Casper transactions. Reads never touch the chain state-changing path: they query public data or account balances. Writes each sign and submit a TransactionV1.

Signing Casper TransactionV1

Every write is a Casper 2.0 (Condor) TransactionV1, built and signed with casper-js-sdk v5 (agent/src/signer.ts). The signer loads the agent’s key from a PEM file (secp256k1 by default, ed25519 optional), builds the transaction against a contract package hash (so writes survive contract upgrades), signs it, and submits it over JSON-RPC.

const tx = new ContractCallBuilder()
  .byPackageHash(ATTESTATION_REGISTRY)   // package hash: upgrade-safe
  .entryPoint('attest')
  .runtimeArgs(args)                     // asset_id, period, amount (U512), source_hash
  .chainName('casper-test')
  .payment(20_000_000_000, 1)            // gas limit in motes (1 CSPR = 1e9 motes)
  .from(key.publicKey)
  .build();
 
tx.sign(key);                            // signed with the attester key
const res = await rpc.putTransaction(tx);
return res.transactionHash.toHex();

const tx = new NativeDelegateBuilder()
  .validator(PublicKey.fromHex(validatorHex))
  .amount(amountMotes)
  .chainName('casper-test')
  .payment(2_500_000_000, 1)             // 2.5 CSPR gas limit
  .from(key.publicKey)
  .build();
 
tx.sign(key);
await rpc.putTransaction(tx);

const tx = new SessionBuilder()
  .wasm(proxyWasm)                       // wiselending-proxy.wasm
  .runtimeArgs(args)                     // package_hash, entry_point, attached_value, ...
  .chainName('casper-test')
  .payment(15_000_000_000, 1)            // 15 CSPR gas limit
  .from(key.publicKey)
  .build();
 
tx.sign(key);
await rpc.putTransaction(tx);

Each call returns the transaction hash, which the tool surfaces with a https://testnet.cspr.live/transaction/<hash> explorer link, so every autonomous action is publicly auditable.

Funding itself via x402

The agent pays for its own gas with revenue from the data it produces. The same feed it attests on-chain is also sold over the x402 metered endpoint: a client that wants a fresh reading is quoted a price in WCSPR, signs a WCSPR transfer_with_authorization, and the facilitator settles that payment on Casper. The WCSPR lands with the agent.

During the cycle, read_x402_earnings queries the agent’s WCSPR balance and reports it as treasury available to reinvest. The model is told to count this income as part of the treasury, so the loop is closed: selling the oracle feed funds the attestations and the yield operations that follow.

Staking idle treasury

When the agent has more than the 500 CSPR stake minimum liquid, it puts the idle balance to work rather than letting it sit. The reinvest tool has three outcomes.

Whatever the agent decides, it calls record_reinvest to write the decision to the TreasuryVault contract. Each record is a Reinvestment { venue, amount_in, amount_out, reasoning, timestamp }; the contract appends it, bumps the count, and accumulates the per-venue and total amounts, emitting a Reinvested event. Only the agent may call it. The result is an on-chain, auditable ledger of every capital decision the agent has made and why.

pub struct Reinvestment {
    pub venue: String,        // "wiselending", "native_delegation", or "hold"
    pub amount_in: U512,
    pub amount_out: U512,
    pub reasoning: String,    // the agent's one-sentence justification
    pub timestamp: u64,       // chain block time, epoch ms
}

Why this design is safe to run unattended

The agent acts without human approval, so its safety comes from structure, not supervision:

• Gated. Nothing is written until the on-chain ZK eligibility credential is confirmed. An ineligible agent stops the cycle.
• Validated. A value is attested only if it passes the anomaly check against the feed’s typical range. Suspect data is skipped with an explanation.
• Deduplicated. The heartbeat runs a cycle only on a strictly newer period, so the agent never burns gas re-writing an unchanged value.
• Authorized. Only the agent account may call attest and record_reinvest; every on-chain value and decision carries a verifiable signer.
• Conservative. Treasury moves require a 500 CSPR liquid minimum, are kept small, and holding is always a valid choice.

Related