Digital Assets

When autonomous agents move value, every action must be provable.

Cryptographic governance for AI agents that transact on-chain. When an AI agent moves money, the governance question is immediate: was this action authorized? Was the agent operating within bounds? Can you prove it?

Schedule a briefing
The problem

AI agents are entering on-chain economies.

Autonomous AI agents are entering on-chain economies — executing trades, managing liquidity, interacting with DeFi protocols, and transacting value with minimal human oversight. When an AI agent moves money, the governance question is immediate: was this action authorized? Was the agent operating within bounds? Can you prove it to a regulator, counterparty, or auditor?

Most AI governance tools were designed for chat safety. They filter text. In digital assets and DeFi, the output isn't text — it's a financial transaction with real value at risk.

How Kevros helps

Per-action governance for financial agents.

Per-Action Authorization
Every agent transaction — trades, swaps, liquidity operations, token transfers — requires a cryptographic release token before execution. If denied, no token and the transaction cannot proceed.
x402 Payment Protocol
Per-call payment using Base USDC. AI agents can pay for governance verification on a per-transaction basis without subscriptions or pre-funded accounts. Autonomous agents self-fund their governance costs.
Post-Quantum Transaction Integrity
On-chain transactions create long-lived financial records subject to regulatory review years after execution. ML-DSA-87 post-quantum signatures ensure evidence remains verifiable regardless of quantum computing advances.
Hash-Chained Provenance
Every governance decision is recorded in a tamper-evident provenance ledger. When a regulator, auditor, or counterparty needs to verify that an agent operated within authorized bounds — the evidence chain is complete.
Peer Trust for Agent Transactions
In multi-agent DeFi ecosystems, agents transacting with each other verify counterparty identity and authorization. Peer trust allows any agent to check another agent's governance history before accepting a transaction.
Formally Verified
Enforcement kernel exhaustively verified via TLA+ across 32.8 million state configurations. Zero safety violations found. Formal assurance that governance decisions are correct before value moves.
Coinbase-Compatible Stack, Governed

Compatible with Coinbase infrastructure. Every layer governed.

Kevros is compatible with Coinbase infrastructure — including x402 payment settlement, Onramp wallet funding, and AgentKit framework actions. Every interaction point is governed with cryptographic proof.

x402 Pay-Per-Call
Pay for governance with USDC on Base. No signup, no API key, no subscription. Your agent’s wallet pays per call. Settled on-chain via Coinbase facilitator.
Verify $0.01 · Attest $0.02 · Bind $0.02 · Bundle $0.25
AgentKit ActionProvider
Add governance to any AgentKit agent with one import. Four actions: verify, attest, bind, check peer trust. Published on PyPI and npm.
pip install coinbase-agentkit-kevros
Coinbase Onramp
Fund your agent’s wallet via Coinbase. Apple Pay, debit card, or Coinbase balance. USDC on Base, ready for x402 governance calls.
Wallet-Agent Binding
Cryptographically bind a Coinbase wallet to a governance identity. Every on-chain transaction traced back to a governed agent with hash-chained provenance.
MCP + A2A Discovery
Kevros governance is discoverable via MCP (Smithery) and A2A (.well-known/agent.json). AI agents find and verify governance automatically.

AgentKit Integration

Add governance to any Coinbase AgentKit agent
from coinbase_agentkit import AgentKit, AgentKitConfig from coinbase_agentkit.wallet_providers import CdpEvmWalletProvider from kevros_agentkit import kevros_governance_provider # One import, four governance actions agent = AgentKit(AgentKitConfig( wallet_provider=CdpEvmWalletProvider(...), action_providers=[kevros_governance_provider(agent_id="trading-bot")] )) # Agent verifies before every trade result = agent.run("Verify this ETH/USDC swap is within policy bounds") # → ALLOW + signed release token + hash-chained provenance record
Get started with AgentKit
PyPI npm
Code examples

Real SDK examples for digital asset governance.

Official examples using the Kevros SDK. Governance boundaries are configured server-side through the gateway. All code on this page is the canonical reference.

Trading Agent — Verify Before Executing a Swap

from kevros_governance import GovernanceClient client = GovernanceClient(agent_id="trading-agent-eth") # Verify authorization before executing a swap result = client.verify( action_type="swap", action_payload={ "pair": "ETH/USDC", "side": "SELL", "amount_eth": 10.0, "expected_usdc": 34125.00, "protocol": "uniswap_v3", "chain": "base", }, agent_id="trading-agent-eth", ) if result.decision.value == "ALLOW": execute_swap( release_token=result.release_token, pair="ETH/USDC", amount=10.0, ) # Record the execution client.attest( agent_id="trading-agent-eth", action_description="Sold 10 ETH for USDC on Uniswap V3 (Base)", action_payload={ "pair": "ETH/USDC", "amount_eth": 10.0, "filled_usdc": 34089.50, "slippage_bps": 10, "tx_hash": "0xabc123...", }, ) elif result.decision.value == "DENY": print(f"Swap denied: {result.reason}")

DeFi Lending — Full Governance Loop

from kevros_governance import GovernanceClient, IntentType client = GovernanceClient(api_key="kvrs_your_key_here") # 1. BIND — Declare intent to adjust lending position bind = client.bind( agent_id="lending-manager", intent_type=IntentType.AI_GENERATED, intent_description="Increase USDC collateral in Aave V3 pool", command_payload={ "protocol": "aave_v3", "action": "supply", "asset": "USDC", "amount": 50000, "chain": "base", }, goal_state={"collateral_increased": True, "health_factor_above": 1.5}, ) # 2. VERIFY — Is this operation authorized? verify = client.verify( action_type="defi_supply", action_payload={ "protocol": "aave_v3", "asset": "USDC", "amount": 50000, }, agent_id="lending-manager", ) if verify.decision.value == "ALLOW": # 3. Execute on-chain tx = supply_to_aave(verify.release_token, amount=50000) # 4. ATTEST — Record what happened attest = client.attest( agent_id="lending-manager", action_description="Supplied 50,000 USDC to Aave V3 on Base", action_payload={ "protocol": "aave_v3", "asset": "USDC", "amount": 50000, "tx_hash": tx.hash, "new_health_factor": tx.health_factor, }, ) # 5. VERIFY OUTCOME — Did the result match intent? outcome = client.verify_outcome( agent_id="lending-manager", intent_id=bind.intent_id, binding_id=bind.binding_id, actual_state={ "collateral_increased": True, "health_factor_above": tx.health_factor, }, ) print(f"Outcome: {outcome.status} ({outcome.achieved_percentage}%)")

Agent Wallet Trust — Verify Counterparty Before Transacting

from kevros_governance import GovernanceClient client = GovernanceClient(agent_id="payment-agent") # Before sending funds to another agent, check their governance history peer = client.verify_peer("merchant-agent-042") if peer.get("trust_score", 0) > 0.9 and peer.get("chain_length", 0) > 100: # Trusted counterparty with established history result = client.verify( action_type="token_transfer", action_payload={ "to_agent": "merchant-agent-042", "asset": "USDC", "amount": 500, "chain": "base", }, agent_id="payment-agent", ) if result.decision.value == "ALLOW": send_usdc(to="merchant-agent-042", amount=500, token=result.release_token) else: print(f"Counterparty trust insufficient: {peer.get('trust_score')}")
x402 per-call pricing

Pay-per-call via Base USDC.

No subscription required. AI agents can pay for governance verification on a per-transaction basis, self-funding governance costs from their operational wallets.

Verify
$0.01
per call
Attest
$0.02
per call
Bind
$0.02
per call
Media Attest
$0.05
per call
Compliance Bundle
$0.25
per call
Coinbase infrastructure

Compatible with Coinbase infrastructure.

Kevros uses Coinbase infrastructure for on-chain payments and wallet funding. Compatible with the x402 payment protocol, Onramp fiat-to-crypto conversion, and AgentKit framework.

x402 Ecosystem
Listed in the official x402 ecosystem as a governance service endpoint. Per-call USDC payments on Base for all five governance operations.
x402.org/ecosystem
Coinbase Onramp
Fiat-to-crypto conversion for funding agent wallets with USDC via credit card, debit, or bank transfer.
Coinbase Onramp docs
AgentKit Integration
Published governance ActionProviders for Coinbase AgentKit. Python and TypeScript SDKs wrap governance operations as agent tools.
PyPI npm
Smart Wallet
Compatible with Coinbase Smart Wallet for agent wallet management. Non-custodial, user-controlled keys. USDC on Base.
Coinbase Smart Wallet
Compliance note

Kevros is a software governance tool.

Kevros provides technical governance controls. Using Kevros does not confer compliance with SEC regulations, FINRA requirements, state money transmitter laws, or any other financial regulation. Kevros is a software governance tool — it does not custody assets, execute trades, transmit funds, or provide financial advice.

Organizations use Kevros governance capabilities as components within their own compliance programs. The x402 payment integration uses Coinbase infrastructure for fiat-to-crypto conversion — Kevros does not handle fiat currency.

See our full compliance posture at /compliance.

What Kevros does NOT do in digital assets

Precision about our capabilities.

Kevros verifies whether an AI agent is authorized to take a financial action. It does not:

Execute trades or interact with DEX contracts directly
Custody or hold digital assets
Perform sanctions screening (integrate OFAC/sanctions services separately)
Screen transactions for anti-money laundering (integrate AML services separately)
Manage wallet private keys
Provide financial advice or risk scoring on market positions
Enforce capital exposure limits, drawdown limits, or slippage parameters directly (configure boundaries server-side)
Developer Note
Governance boundaries are configured server-side through the gateway, not through local JSON policy files. Sanctions screening, AML, and capital limit enforcement are separate services that can be used alongside Kevros.

Govern on-chain agents with cryptographic proof.

Schedule a briefing. We'll walk through how Kevros governs AI agent transactions, the x402 per-call payment protocol, and how provenance evidence supports regulatory requirements. Or deploy the Free Trial on Azure and test it yourself.

Schedule a briefing Deploy Free on Azure Azure Marketplace
sales@taskhawktech.com