Introduction

How do you limit what an AI agent can spend? Give it a Valta wallet, set a hard spending policy, and every attempted spend is checked against that policy in Valta's backend — before money moves, not in the agent's prompt where it could be argued with or ignored.

Valta is financial governance infrastructure for autonomous AI agents: isolated wallets, spending limits, kill switches, and a tamper-evident audit trail. Every action governed by policy, not trust.

Running your own agent, including a local model? The examples below that call agents.run() use Valta's own built-in AI, not your model. If you already have an agent — local (Ollama, llama.cpp), self-hosted, or on any provider — and just want to gate its spend, go straight to Cap: it's provider-agnostic, and with allow() it never proxies the call or sees your model's key. If your agent calls OpenAI and you want it enforced — the agent can't skip the check because it never holds your OpenAI key — use the enforced proxy instead.

What Valta provides

Isolated agent wallets — each agent gets its own USDC wallet. One agent cannot access another's balance.

Spending policies — define daily limits, per-transaction caps, blocked categories. Enforced in code before money moves. Not in the prompt.

Kill switch — freeze any agent instantly with one API call. Financial activity stops immediately.

Tamper-evident audit trail — cryptographic hash chain. Every action logged. Nothing deleted.

SDK + REST API — TypeScript SDK with full type safety. REST API for any language.

Feature status

The core path — create an agent, fund it, set a policy, spend, freeze, audit:

Also in the product

Real and shipped, just not part of that core loop:

Quick example

Create a governed agent, set a spending policy, and run it.

import { ValtaClient } from 'valta-sdk'

const valta = new ValtaClient({
  apiKey: process.env.VALTA_API_KEY,
})

// Create a governed agent
const agent = await valta.agents.create({
  name: 'CFO Agent',
  description: 'Monitors wallet balances and reports on spending',
})

// Set a spending policy
await valta.policies.create({
  agentId: agent.id,
  dailyLimit: 50,
  maxPerTransaction: 10,
  requireApprovalAbove: 25,
})

// Run the agent
const run = await valta.agents.run(agent.id, {
  task: 'Check my wallet balance and summarise it in one sentence.',
})

console.log('Status:', run.status)    // 'completed'
console.log('Output:', run.summary)

// Prove the policy is real: send a request over the $10 limit
const denied = await valta.spend({ agent: agent.id, amount: 25, purpose: 'over-limit test' })
console.log('Approved:', denied.approved) // false
console.log('Reason:', denied.reason)     // "Amount $25 exceeds per-transaction limit of $10..."

// Read the audit trail — the deny above is in here
const { data: entries } = await valta.audit.list({ agentId: agent.id })
console.log(`${entries.length} audit entries logged`)

Where to go next

• Quickstart — install the SDK and run your first governed agent in 5 minutes
• The Demo Deny, Explained — why the first thing every account proves is a blocked spend
• Kill Switch — freeze an agent instantly
• SDK Installation — full installation and configuration reference
• API Reference — REST API for any language
• LangChain · CrewAI · OpenAI Agents SDK — Python framework guides, no SDK needed
• Platform Status — what is available today and what is coming