AgentaOS

The Financial OS for the Agent Economy

Accept payments. Automate spending. Enforce guardrails on every transaction.

Quick Start · SDK · CLI · MCP Server · Paper · Website

---

What is AgentaOS

The financial infrastructure for agents and the businesses they transact with.

• Agents get wallets. Your AI agents spend autonomously — pay for APIs, settle invoices, execute trades.
• You set the rules. Spending caps, approved vendors, daily budgets, business hours — enforced on every transaction. Agents cannot bypass them.
• Businesses accept agent payments. One checkout for humans and AI agents. Instant settlement. No integration headaches.
• No single point of failure. Private keys are split across three independent parties. No one — not even you — ever holds the full key.

---

Get Started in 30 Seconds

From the browser

Go to app.agentaos.ai, create a wallet, set your guardrails, and start transacting.

From the terminal

npm install -g agentaos
agenta login
agenta init
agenta send 0xRecipient 0.01

From code

npm install @agentaos/sdk

import { Agenta } from '@agentaos/sdk';
import { createWalletClient, http, parseEther } from 'viem';
import { baseSepolia } from 'viem/chains';

const agent = await Agenta.connect({
  apiSecret: process.env.AGENTA_API_SECRET!,
  apiKey: process.env.AGENTA_API_KEY!,
});

const client = createWalletClient({
  account: agent.toViemAccount(),
  chain: baseSepolia,
  transport: http(),
});

const hash = await client.sendTransaction({
  to: '0xRecipient...',
  value: parseEther('0.01'),
});

agent.destroy();

---

Packages

Package	npm	What it does
@agentaos/sdk		Threshold signing SDK — load shares, sign transactions, viem integration
agentaos		CLI + MCP server for AI assistants
@agentaos/core		Interfaces and types (zero deps)
@agentaos/engine		CGGMP24 threshold ECDSA scheme
@agentaos/chains		Ethereum chain adapter (viem)
@agentaos/crypto		CGGMP24 Rust WASM bindings

---

SDK

Connect

import { Agenta } from '@agentaos/sdk';

// Credentials from app.agentaos.ai → Create Wallet → copy credentials
const agent = await Agenta.connect({
  apiSecret: process.env.AGENTA_API_SECRET!,
  apiKey: process.env.AGENTA_API_KEY!,
});

Send ETH

const { txHash } = await agent.signTransaction({
  to: '0xRecipient...',
  value: parseEther('0.01'),
});

Call a Contract

const { txHash } = await agent.signTransaction({
  to: '0xContract...',
  data: '0xa9059cbb...', // ERC-20 transfer
  value: 0n,
});

Sign a Message

const { signature, r, s, v } = await agent.signMessage('Hello from AgentaOS');

viem Drop-in

import { createWalletClient, http } from 'viem';
import { baseSepolia } from 'viem/chains';

const client = createWalletClient({
  account: agent.toViemAccount(), // LocalAccount — works everywhere viem does
  chain: baseSepolia,
  transport: http(),
});

const hash = await client.sendTransaction({ to, value });
const sig = await client.signMessage({ message: 'hello' });
const sig = await client.signTypedData({ domain, types, primaryType, message });

Cleanup

agent.destroy(); // Wipes share material from memory

---

CLI

npm install -g agentaos

Command	What it does
agenta init	Create or import a signer
agenta status	Signer info and connection status
agenta balance	ETH balance
agenta send <to> <amount>	Send ETH — threshold-signed, policy-checked
agenta sign-message <msg>	Sign an arbitrary message
agenta deploy <bytecode>	Deploy a smart contract
agenta proxy	JSON-RPC signing proxy for Foundry/Hardhat

agenta init
agenta send 0xRecipient 0.01 --network base-sepolia
agenta sign-message "proof-of-liveness"
agenta proxy --port 8545  # then: forge script Deploy.s.sol --rpc-url http://localhost:8545 --broadcast

---

MCP Server

Connect any AI assistant to AgentaOS. Claude, Cursor, Windsurf — they sign transactions through the MCP protocol.

Claude Desktop

{
  "mcpServers": {
    "agenta": {
      "command": "npx",
      "args": ["-y", "agentaos", "mcp"],
      "env": {
        "AGENTA_API_KEY": "your-api-key",
        "AGENTA_API_SECRET": "your-api-secret"
      }
    }
  }
}

Your API Key and API Secret are generated when you create a wallet at app.agentaos.ai. Copy them from the credentials screen.

Tools

Tool	What it does
wallet_overview	Address, balance, network
get_balances	ETH + ERC-20 balances
send_eth	Send ETH
send_token	Send ERC-20 tokens
sign_message	Sign a message
sign_typed_data	Sign EIP-712 typed data
call_contract	Write to a contract
read_contract	Read contract state
simulate	Simulate a transaction
list_signers	List configured signers
list_networks	Supported networks
get_audit_log	Signing history

---

Framework Integrations

Vercel AI SDK

import { Agenta } from '@agentaos/sdk';
import { tool } from 'ai';
import { parseEther } from 'viem';
import { z } from 'zod';

const agent = await Agenta.connect({
  apiSecret: process.env.AGENTA_API_SECRET!,
  apiKey: process.env.AGENTA_API_KEY!,
});

const sendETH = tool({
  description: 'Send ETH using threshold signing',
  parameters: z.object({
    to: z.string().describe('Recipient address'),
    amount: z.string().describe('Amount in ETH'),
  }),
  execute: async ({ to, amount }) => {
    const result = await agent.signTransaction({
      to,
      value: parseEther(amount).toString(),
    });
    return { txHash: result.txHash };
  },
});

LangChain

import { Agenta } from '@agentaos/sdk';
import { DynamicStructuredTool } from '@langchain/core/tools';
import { parseEther } from 'viem';
import { z } from 'zod';

const agent = await Agenta.connect({
  apiSecret: process.env.AGENTA_API_SECRET!,
  apiKey: process.env.AGENTA_API_KEY!,
});

const sendETH = new DynamicStructuredTool({
  name: 'agenta_send_eth',
  description: 'Send ETH using threshold signing',
  schema: z.object({ to: z.string(), amount: z.string() }),
  func: async ({ to, amount }) => {
    const result = await agent.signTransaction({
      to,
      value: parseEther(amount).toString(),
    });
    return JSON.stringify({ txHash: result.txHash });
  },
});

Foundry / Hardhat

agenta proxy --port 8545
forge script Deploy.s.sol --rpc-url http://localhost:8545 --broadcast

---

Examples

See examples/ for complete working code:

• viem-client — Send ETH with the SDK
• vercel-ai-sdk — AI agent with signing tools
• langchain — LangChain agent integration
• claude-agent-sdk — Claude agent with signing
• mcp — MCP server usage and testing
• forge-proxy — Foundry deployment through signing proxy

---

How It Works

Three Signing Paths

Path	Shares	When
Signer + Server	Agent share + Server share	Normal autonomous operation
User + Server	Passkey-encrypted share + Server share	Browser manual signing
Signer + User	Agent share + User share	Server down or bypass

Security Model

• The full private key is never reconstructed — signing is a distributed computation between two share holders
• Server shares are wiped from memory (buffer.fill(0)) after every operation
• API keys stored as SHA-256 hashes — plaintext exists only on your machine
• Based on the audited LFDT-Lockness/cggmp21 Rust crate
• Peer-reviewed cryptographic foundation: ePrint 2021/060

Read the research: AgentaOS: Threshold Custody for the Agent Economy — our published paper on the security model, signing architecture, and trust guarantees behind AgentaOS.

Supported Networks

Ethereum, Base, Arbitrum, Optimism, Polygon — mainnet and testnet. All EVM chains supported.

---

Environment Variables

Variable	Description
AGENTA_API_KEY	API key — generated when you create a wallet
AGENTA_API_SECRET	API secret — your signing credential, shown once at creation
AGENTA_SERVER	Optional — defaults to https://api.agentaos.ai

---

Contributing

git clone https://github.com/AgentaOS/agentaos.git && cd agentaos
pnpm install && pnpm build && pnpm test

See CONTRIBUTING.md for guidelines.

---

License

Apache-2.0. See LICENSE.

Copyright 2025-2026 Aristokrates OU

---

agentaos.ai · npm · Security · Issues