SENTINEL.

Autonomous treasury agent · QoreChain testnet

The treasury agent that cannot overspend

Sentinel pays invoices on its own. Every limit on its spending is enforced by a different layer of qorechain-diana: two inside the consensus protocol, one in a Solidity vault that verifies post-quantum signatures with native precompiles.

→ hand the classical key to an attacker;
it stops at the protocol.

Three concentric enforcement bounds around the agent key L0 · Scoped EVM window L1 · Spending rules L2 · PolicyVault AGENT KEY ECDSA AT CENTRE · PQ SECRET ABSENT
Invoices settled
from chain events
Refused on-chain
PaymentRefused logs
Window budget
QOR left in scope
Vault balance
QOR held
Latest decision
–

01 / Premise

Elsewhere, an agent's budget is a line of app code

On a typical EVM chain, "spending limits" for an AI agent live in the same software the agent runs, or in one contract. One leaked key or one bug and they're gone. Sentinel moves each limit into a separate enforcer the agent cannot reach.

ThreatTypical agent walletSentinel on QoreChain
Agent key leaksAttacker can send funds anywhere the key can sign for.The chain rejects any tx whose target isn't the vault or registry, before execution.
Contract bugAll limits fall with the one contract that holds them.Two more independent limits live in the protocol: the EVM window and the abstract-account rule.
Large paymentApproved by whoever holds a classical key.Needs an operator ML-DSA-87 mandate, verified in Solidity by the pqcVerify precompile.
Agent tries to widen its scopeCalls an admin function with its own key.Widening needs the account's PQ key. The agent process never holds the recovery code it derives from.
Quantum adversaryForges ECDSA, owns everything.Forged ECDSA gets only the agent's bounded slice. Mandates and window control are post-quantum.

02 / Bounds

Three enforcers. Two doors, one vault

The window and the spending rule are parallel doors into the same vault, not layers inside each other — each bounds what the key can do through its own rail. The vault alone bounds what actually gets paid. Hover a bound to find it in the diagram.

L0 · chain window L1 · abstract account L2 · policy vault L3AGENT
L0consensus

Scoped EVM window

The agent's EOA can only broadcast EVM transactions inside a window opened by a hybrid-signed native tx. The window names its allowed targets; anything else is rejected at broadcast, with no contract code involved. Its budget covers the key's own tx value and gas — payouts are the vault's business.

allowed_targets = [vault, registry]17,280 blocksmax 20 txs4 QOR tx-value + gas budget

open tx · A6293E8A…655F

L1x/abstractaccount

Abstract-account spending rules

The agent key is also linked as an authenticator on the operator's abstract account — calls authorized by it execute as the operator. The spending rule therefore lists calls down to the function selector: pay and payWithMandate only. A bare allowed_evm_calls = [vault] would trust every admin function.

rule sentinel-agent-evmcalls = vault/pay + payWithMandate1 QOR / tx5 QOR / dayexpires in 7 days

link tx · 14FE8A99…7733 · re-scoped F1F3F4A3…E9AA

L2solidity + PQC precompiles

PolicyVault

Holds the treasury and re-checks every payment no matter what the agent decided: pause, vendor allowlist, per-tx cap, UTC-day cap. This is the layer that actually bounds payout amounts. Above the threshold it needs an operator ML-DSA-87 mandate verified by pqcVerify (0x0A01). Admin calls re-check pqcKeyStatus (0x0A02). Refusals are emitted on-chain.

per-tx 5 QORdaily 20 QORmandate > 2 QORvendor allowlistpause

contract · qor1rq3p…49kk

L3services

Agent & guardian

The agent scans the registry, decides, signs an EIP-712 receipt and calls pay. A separate guardian renews the window, issues mandates and runs the kill switch. The agent holds only its classical key, so it can't open its own window.

agent/ · scan → decide → receipt → payguardian/ · renew · mandate · killLLM veto-only

source · agent/ · guardian/

03 / Custody

Who holds which key, and what they can't do

Authority is split across three processes. The hot one, the agent, is also the one with the least power.

Operator · guardian-held

Owner

ML-DSA-87 + ECDSA, hybrid-signed

  • Opens and closes EVM windows
  • Links authenticators and spending rules
  • Signs payment mandates above threshold
  • Sets policy, allowlist, pause

Guardian · warm

Supervisor

holds the operator key + the agent's PQC recovery code

  • Renews the agent's scoped window when it runs low
  • Auto-issues mandates within an approval ceiling
  • Kill switch: revokes the authenticator, closes the window, pauses the vault
  • Decides what to pay

Agent · hot

Sentinel

classical secp256k1 only

  • Scans invoices, decides, signs EIP-712 receipts
  • Calls pay on the vault
  • Open or widen its own window
  • Sign a mandate
  • Reach a non-allowlisted contract — through either rail
  • Call any vault function but pay via the account

→ The agent's ML-DSA-87 key derives from QORE_PQC_RECOVERY_CODE, which only guardian/env.ts loads. agent/config.ts loads only PRIVATE_KEY.

04 / Lifecycle

The life of one payment

The agent's own judgement comes first, but the chain gets the final word, three times.

  1. 1

    Scan

    Read pending invoices from the registry.

    InvoiceRegistry.invoice(id)
  2. 2

    Decide

    Mirror the vault: pause → allowlist → per-tx → daily → threshold.

    agent/policy.ts
  3. 3

    Review

    An LLM may veto an approved payment. It can never approve a refused one.

    agent/llm.ts · DeepSeek
  4. 4

    Sign

    EIP-712 Decision receipt. decisionRef = keccak256(sig) travels on-chain.

    agent/receipt.ts
  5. 5

    Admit

    The node checks the scoped window: target, tx count, value, expiry.

    L0 · consensus
  6. 6

    Settle

    The vault re-checks policy. Over 2 QOR, pqcVerify checks the operator's ML-DSA-87 mandate.

    L2 · PolicyVault
  7. 7

    Record

    PaymentExecuted or PaymentRefused. Refusals are on-chain too.

    event log
agent processenforced by the chainpost-quantum check

05 / Q-Day drill

On 18 Nov the attacker gets the key. Pick an attack

For the Q-Day Drill the agent account is the target: the attack bot receives Sentinel's classical ECDSA key, the same position a quantum adversary would be in. Here is what it can try and where each attempt stops.

    Drill day

    18 Nov

    The attack bot gets the agent's ECDSA private key.

    What it holds

    The agent's ECDSA key: valid signatures, a funded EOA, a live scoped window. It does not hold the PQ key, the operator account or the guardian.

    After the drill

    Rotate: setAgent → new scoped window → re-linked authenticator. The old key is left with nothing.

    06 / Evidence

    Every claim is a transaction

    Track A rubric mapped to on-chain proof on qorechain-diana (EVM 9800). Addresses and hashes are also in deployments.testnet.json.

    RequirementMechanismProof

    07 / Deployed

    Accounts and contracts

    08 / Known limits

    What this does not claim

    Edges a reviewer should find written down, not discover.

    EdgeReality
    Daily capFixed UTC-day bucket, not rolling — the cap can be spent twice across a midnight boundary.
    Registry settleInvoiceRegistry.settle is operator-callable directly; the vault never marks an invoice Rejected.
    decisionRefStored, not validated — the vault accepts any 32 bytes. PaymentRefused carries none.
    Invoice spamSubmission is permissionless; every refusal costs the window one of its 20 txs.
    Operator keyWarm in the guardian process, not cold — guardian compromise = owner compromise.
    PQC testsvm.etch mocks verify control flow; ML-DSA-87 interop is proven by the live precompile txs.

    Live · read-only · no keys

    Watch it decide

    The board rebuilds Sentinel's history from vault and registry event logs on every refresh, and re-verifies each signed decision receipt against the agent's address.