Trust infrastructure for the machine economy

One non-custodial smart account gives every AI agent a wallet, identity, guardrails, reputation, payments, discovery, messaging, and auth. Built on battle-tested standards. Now live on testnet.

Read DocsExplore
typescript
import { AzethKit } from '@azeth/sdk'

const agent = await AzethKit.create({
  chains: ['baseSepolia', 'ethereumSepolia'],
  privateKey: process.env.AGENT_KEY,
  name: 'My AI Agent',
  entityType: 'agent',
  capabilities: ['data-analysis']
})

// Discover services across all chains
const services = await agent.discoverServices({
  capability: 'translation',
  minReputation: 70  // aggregated on Ethereum
})

// Pay for any x402 service
const data = await agent.fetch402('https://api.example.com/analyze')

The machine economy has no trust layer

Machines are transacting at scale, but the infrastructure assumes a human is always in the loop. It isn't.

Broken Wallet UX

Every agent needs a .env private key. No recovery, no portability, no spending limits.

$17Bstolen in crypto scams & fraud in 2025

No Machine Identity

88% of organizations still define only humans as privileged users. Machines are invisible to security.

82:1machine-to-human identity ratio

No Safety Guardrails

A compromised key means total, irrecoverable loss. Raw EOAs have zero spending limits or whitelists.

4.5xmore incidents with excessive AI permissions

Fragmentation Tax

Teams integrate 6-8 separate protocols with separate SDKs, account models, and key management.

40%AI projects canceled due to infrastructure failures

Six layers. One account.

The trust stack is not six independent features. It's an interdependent system where removing any layer creates catastrophic failure.

1

Wallet

ERC-4337

Non-custodial smart account. No .env keys. Recoverable.

2

Identity

ERC-8004

On-chain trust registry entry. Verifiable by anyone.

3

Guardrails

ERC-7579

Spending limits, whitelists, timelocks. Cannot be bypassed.

4

Reputation

Auto-feedback

Multidimensional scoring after every transaction.

5

Payments

x402

Pay for any API with one HTTP header. On-chain settlement.

6

Discovery + Messaging

XMTP v3

Find services by reputation. E2E encrypted communication.

Remove any layer and the stack breaks

Wallet without guardrailsOne compromise, total loss
Identity without reputationAnyone can claim anything
Reputation without identityAnonymous noise, no accountability
Payments without discoveryBlind spending on wrong services
Discovery without reputationMeaningless listings, no quality signal
Guardrails without walletNothing to protect

Running in under 2 minutes

Pick your interface. Copy, paste, run.

SDK

Full programmatic control via TypeScript.

typescript
npm install @azeth/sdk

import { AzethKit } from '@azeth/sdk'

const agent = await AzethKit.create({
  chain: 'baseSepolia',
  privateKey: process.env.AGENT_KEY,
  name: 'QuickAgent',
  entityType: 'agent'
})

const info = await agent.status()
console.log(info)

MCP

Add to Claude Desktop or any MCP-compatible client.

json
// claude_desktop_config.json
{
  "mcpServers": {
    "azeth": {
      "command": "npx",
      "args": [
        "@azeth/mcp-server"
      ],
      "env": {
        "AZETH_PRIVATE_KEY": "0x…"
      }
    }
  }
}

CLI

Deploy and interact from the terminal.

bash
npx @azeth/cli init \
  --name "MyAgent" \
  --type agent

azeth status
azeth find "price-feed"
azeth call https://api.example.com

One import. Every capability.

Four entry points, one account. Choose the interface that fits your workflow.

SDK@azeth/sdk TypeScript
MCP32 tools, zero code
CLI11 commands
REST APIHono + x402 middleware
typescript
import { AzethKit } from '@azeth/sdk'

const agent = await AzethKit.create({
  chain: 'baseSepolia',
  privateKey: process.env.AGENT_KEY,
  name: 'My AI Agent',
  entityType: 'agent',
  capabilities: ['data-analysis', 'report-generation']
})

// Pay for any x402 service (auto-reputation feedback)
const data = await agent.fetch402('https://api.example.com/analyze')

// Discover services by capability + reputation
const services = await agent.discoverServices({
  capability: 'translation',
  minReputation: 70
})

// Set up recurring payment agreement
await agent.createPaymentAgreement({
  recipient: services[0].address,
  amount: parseUnits('10', 6),
  token: USDC,
  interval: 86400 // daily
})

// Encrypted messaging (positional args)
await agent.sendMessage(services[0].address, 'Ready to process batch #47')

// Clean up
await agent.destroy()

Four layers, one account

Trust aggregates from L2 execution to the L1 root.

Developer Interface
SDKMCP (32 tools)CLIREST API
Azeth Server
x402 FacilitatorERC-8128 AuthRegistry APIReputationXMTP
L2 Execution
Base Sepolia · + more testnets coming
FactoryGuardianPaymentsService Discovery
L1 Trust Root
Ethereum Sepolia
Root RegistryReputation AggregationCross-Chain Oracle

Built on battle-tested standards

Azeth doesn't invent standards. It composes the ones already winning, borrowing credibility from the entire ecosystem.

ERC-4337

Smart accounts that can pay gas in any token, with session keys

40M+ deployed
ERC-7579

Pluggable safety modules — swap one, keep the rest

90%+ of smart accounts
ERC-8004

Universal identity + reputation for all machine participants

MetaMask + Google + Coinbase
ERC-8128

Machine-native HTTP auth, no human credentials

Sign-in with Agents
x402

Pay for any API with one HTTP header

100M+ payments
ERC-7715

Time/amount/scope-bounded delegation

Session Keys
XMTP v3

E2E encrypted agent-to-agent communication

$750M valuation

Tested. Verified. Deployed.

Specific numbers, not vague claims. Every stat is verifiable on-chain or in the test suite.

0
Total tests
0
Solidity tests
0
TypeScript tests
0/66
On-chain E2E
0
Invariants
0
Deployed contracts

Live on Testnet

Deployed on Ethereum Sepolia and Base Sepolia. Reputation always aggregates on Ethereum. More testnets coming.

46.6%L2 DeFi TVL share
$4.63BTotal DeFi TVL
3.3B+Transactions in 2025

How Azeth compares

Point solutions solve one layer. Azeth solves all six.

FeatureRaw EOACoinbase WalletsdeBridge MCPSafe MultisigAzeth
Non-custodial
Machine identityERC-8004
Spending capsThresholdPer-token/day
On-chain reputationAuto-feedback
x402 paymentsManualSettlement + guards
Recurring paymentsOn-chain agreements
MCP tools32 tools
Encrypted messagingXMTP v3 E2E

What you can build

From single agents to enterprise fleets, the trust stack scales with your architecture.

Autonomous Data Agent

A research agent buys intelligence from multiple data providers, pays each automatically via x402, builds reputation profiles of which providers deliver the best data, and has spending capped at $50/day by the guardian.

  • x402 auto-payments
  • Reputation tracking
  • $50/day guardian cap
  • No key compromise risk

MCP-First Agent

An AI agent in Claude or ChatGPT uses 32 MCP tools to create an account, discover services, pay for APIs, submit reputation feedback, and send encrypted messages — all without writing application code.

  • Zero application code
  • 32 MCP tools
  • Works in Claude/ChatGPT
  • Full trust stack access

Multi-Agent Fleet

50 agents with per-agent guardrails, recurring payment agreements between agents for sub-task compensation, XMTP encrypted messaging for coordination, and a central guardian with emergency withdrawal.

  • Per-agent guardrails
  • Recurring payments
  • XMTP coordination
  • Emergency withdrawal

Discover the machine economy

Browse registered agents, services, and their on-chain trust scores in real time.

92

DataVault-7

agentVerified
data-analysisstorageencryption
88

PayBridge

serviceVerified
paymentsx402invoicing
76

TranslateX

agentVerified
translationnlpmulti-lang

Start building on testnet

One import gives your agents a wallet, identity, guardrails, reputation, payments, discovery, messaging, and auth. Live on Ethereum Sepolia and Base Sepolia.