Inside Clawdius.
What we built, how it works, and why every decision was made the way it was.
One tier. Every feature.
No capability gates on security.
Every bot on the platform is equally protected. Security is not a premium feature.
Security
10Prompt Guard
Immutable system prompt, injected at container level
Output Scanner
30+ credential patterns scanned on every response
Tool Blocker
OS-level command restrictions via seccomp profiles
Input Audit
Credential detection on inbound messages
Vault Secret Matching
SHA-256 cross-reference against stored secrets
Circuit Breakers
Rate limits, spend limits, token caps -- proxy-enforced
Memory Gatekeeping
Write confirmation, content scanning, injection detection
Kill Switch
Instant bot shutdown from dashboard
Audit Logging
Every security event logged with full context
Incident Response
Automatic containment, self-assessment, recovery
Wallet & DeFi
10Privy Integration
Embedded wallet with delegated signing
Circle Integration
Programmable wallet with developer-controlled signing
ERC-4337 Smart Accounts
Gasless transactions, batch operations, recovery
Uniswap V4 Swaps
Token swaps across 6 EVM chains
Hyperliquid Trading
Perpetual futures + spot with withdrawal-locked agent wallet
x402 Payments
Autonomous API payments via USDC -- no keys needed
MoonPay On-Ramp
Fiat to crypto directly in the dashboard
ERC-7710 Spending Controls
On-chain delegation with 36 caveat enforcers
Recovery Addresses
Per-chain fund sweep on deletion
Tiered Verification
4-tier auth from chat confirmation to dashboard re-auth
Agent Identity
5ERC-8004 Identity
On-chain NFT registry with reputation and validation
ERC-8128 Signed HTTP
Per-request cryptographic authentication
A2A Protocol
Google Agent-to-Agent compatibility built in
AgentCard
Public JSON identity discoverable by other agents
Per-Sender Reputation
Trust scores, auto-blocking, coordinated attack defense
Intelligence
650+ Pre-Built Skills
Ships smart on day one
Secure Skill Rebuilding
Discovers tools, rebuilds from scratch -- zero third-party code
5-Layer Memory System
Pinned facts, cold archive, temporal awareness, pattern recognition
Scheduled Task Manager
Bot-owned automation with dashboard oversight
Credential Rotation
Detect expired keys, guide rotation, execute autonomously
Per-Bot Email (AgentMail)
Your bot gets its own email address
Infrastructure
6AWS Fargate Containers
Isolated, auto-scaling, no shared resources
Encrypted EFS Storage
Per-bot encrypted file system
AWS Secrets Manager Vault
Hardware-backed credential storage
Replay Attack Prevention
Webhook deduplication + financial idempotency keys
Cross-Bot Isolation
EFS access points, IAM scoping, network isolation
Graceful Degradation
Every dependency failure has a fallback plan
Most platforms show you a feature grid and ask you to trust them. We would rather show you the architecture and let you decide for yourself. This page is a technical walkthrough of every layer in the Clawdius stack, from the proxy that intercepts every message to the on-chain identity that makes your bot verifiable by anyone, anywhere.
Five security layers sit between your bot and the outside world. Not five bullet points on a marketing page — five infrastructure-enforced boundaries, each operating independently, each with its own failure mode and recovery path. The proxy scans thirty credential patterns on every outbound message. The container runs behind seccomp profiles that restrict OS-level commands. The vault cross-references every value against stored secrets using SHA-256 hashing. None of this touches your bot’s code. None of it can be disabled from inside the container.
Your bot gets a real wallet — not a simulated balance, not an API key to someone else’s account. A cryptographic key pair managed by Privy’s hardware-backed infrastructure, with spending controls enforced on-chain through ERC-7710 delegation. The blockchain itself limits what the bot can spend, on which tokens, on which contracts, for how long. If the bot tries to exceed its limits, the smart contract reverts the transaction. Not our code. Math.
Every HTTP request your bot sends is cryptographically signed with its wallet. Every bot gets an on-chain identity through ERC-8004 — a permanent, discoverable record on Ethereum mainnet backed by the Ethereum Foundation, MetaMask, Google, and Coinbase. Twenty-four thousand agents are already registered. Other agents and services can look up your bot, verify its signatures, and decide whether to trust it. No bearer tokens. No shared secrets. The wallet is the authentication.
What follows is the full technical breakdown. Code samples are real patterns from the Clawdius codebase. Every claim on this page can be verified in the architecture, in the smart contracts, or in the standards we build on.
For the builders
Open standards. Real code. No black boxes.
Every security layer, every ERC integration, every SDK abstraction — built on standards you can audit, extend, and trust. The code samples below are real patterns from the Clawdius codebase.
The Security Stack
Five layers of infrastructure-enforced security between your bot and the outside world. The proxy intercepts every message in and out. The container enforces OS-level restrictions. The agent never touches any of it.
Scan layers: rate_limit, input_validation, prompt_guard, output_regex, vault_match. Actions: allow, redact, block. Every scan result is logged to DynamoDB with full context.
// 30+ patterns. Here's a taste.
const CREDENTIAL_PATTERNS = [
{ name: 'aws_access_key', regex: /AKIA[0-9A-Z]{16}/ },
{ name: 'anthropic_key', regex: /sk-ant-[a-zA-Z0-9_-]{20,}/ },
{ name: 'github_token', regex: /(ghp|gho|ghs|github_pat)_[a-zA-Z0-9_]{20,}/ },
{ name: 'stripe_key', regex: /(sk|pk|rk)_(live|test)_[a-zA-Z0-9]{10,}/ },
{ name: 'jwt', regex: /eyJ[a-zA-Z0-9_-]{10,}\.eyJ[a-zA-Z0-9_-]{10,}\.[a-zA-Z0-9_-]+/ },
{ name: 'ssh_private_key', regex: /-----BEGIN (RSA|OPENSSH|EC|DSA) PRIVATE KEY-----/ },
{ name: 'eth_private_key', regex: /0x[0-9a-fA-F]{64}/ },
// ... 23 more patterns
] as const;
// Scan result: { action: 'allow' | 'redact' | 'block' }
// Runs on EVERY outbound message at the proxy layer.
// The agent never sees the original value.ERC-7710 Delegation
Granular, revocable on-chain permissions. Your bot can spend up to $X/day, only on approved tokens, only on approved contracts. The blockchain enforces it — not our code. 36 audited caveat enforcer contracts from MetaMask's delegation framework.
36 audited caveat enforcer contracts. Consensys Diligence audit. Self-deployment to any EVM chain. Viem-native. TypeScript SDK.
// On-chain spending controls — enforced by smart contracts, not software.
// Using MetaMask's Smart Accounts Kit (ERC-7710)
const delegation = await createDelegation({
delegate: botWalletAddress,
caveats: [
AllowedTargets([UNISWAP_V4_ROUTER]), // Only Uniswap
SpendingLimit(parseEther('100'), 'USDC'), // Max 100 USDC/day
AllowedTokens(['USDC', 'ETH', 'WETH']), // Approved tokens only
TimeBound(now, now + 30 * DAY), // 30-day expiry
],
});
// Bot tries to exceed limit:
// --> Smart contract REVERTS. Not our code. The blockchain itself.
// Effective limits computed from Privy policies + on-chain caveats:
// daily_limit_usd, allowed_tokens, allowed_targets, sourceERC-8128 Signed HTTP
Every HTTP request your bot sends is cryptographically signed with its wallet. The signature covers the method, path, query, and body — any tampering invalidates it. No bearer tokens. No shared secrets. The wallet IS the authentication.
RFC 9421 HTTP Message Signatures + EIP-191 Ethereum signed data. Per-request cryptographic binding. Replay-protected with nonces. Out of the box for every bot.
// Every API call your bot makes can be cryptographically signed.
// Built on RFC 9421 (HTTP Message Signatures) + EIP-191.
const response = await authenticatedRequest({
url: 'https://api.external-service.com/data',
method: 'POST',
body: JSON.stringify({ query: 'ETH price' }),
});
// What the receiving service gets:
// Signature-Input: sig1=("@method" "@path" "content-digest");
// keyid="0x742d...0bEb";nonce="abc123";created=1707350400
// Signature: sig1=:BASE64_ECDSA_SIGNATURE:
//
// The service recovers the wallet address from the signature,
// looks up the bot's ERC-8004 AgentCard, and trusts — or rejects.ERC-8004 Identity
An on-chain registry backed by the Ethereum Foundation, MetaMask, Google, and Coinbase. Your bot gets a permanent, discoverable identity as an ERC-721 NFT. 24,000+ agents already registered. Live on Ethereum mainnet since January 2026.
24,000+ agents registered on ERC-8004. Backed by Ethereum Foundation, MetaMask, Google, Coinbase. Live on mainnet since January 2026.
// Your bot's public AgentCard — discoverable on-chain.
// /.well-known/agent-card.json
{
"type": "https://eips.ethereum.org/EIPS/eip-8004#registration-v1",
"name": "Clawdius DeFi Assistant",
"description": "Autonomous trading bot with Uniswap integration",
"services": [
{
"endpoint": "https://app.clawdius.com/agents/{botId}/mcp",
"protocol": "mcp",
"capabilities": ["token-swap", "price-quote", "scheduled-tasks"]
}
],
"evm_address": "0x742d...0bEb",
"supportedTrust": ["reputation", "tee-attestation"],
"chains": ["ethereum", "base", "unichain"]
}Hyperliquid Agent Wallet
Your bot gets a restricted agent wallet on Hyperliquid — the deepest liquidity in DeFi ($4B+ daily volume). It can place orders, open positions, manage risk. But it can NEVER withdraw funds. Not because we said so. Because the exchange cryptographically enforces it.
EIP-712 signed. Nonce-protected. Replay-proof. Risk controls enforced at proxy level before signing reaches the exchange.
// Agent wallet: can trade, can NEVER withdraw.
// Enforced by Hyperliquid's exchange — not our code.
// EIP-712 typed data signing for every trade action:
const signature = await signTypedData({
domain: {
name: 'Exchange',
version: '1',
chainId: 42161, // Arbitrum
verifyingContract: '0x...',
},
types: {
Order: [
{ name: 'asset', type: 'uint32' },
{ name: 'isBuy', type: 'bool' },
{ name: 'limitPx', type: 'uint64' },
{ name: 'sz', type: 'uint64' },
{ name: 'nonce', type: 'uint64' }, // Replay protection
],
},
value: orderParams,
});
// Risk controls enforced at proxy level BEFORE signing:
// - Max position size (% of account)
// - Max leverage
// - Max open positions
// - Daily loss limit (% of starting balance)Every feature on this page ships with every bot.
One tier. No capability gates on security. No premium add-ons for the architecture that keeps your bot safe.