Welcome

RobotMoney is infrastructure for trusted agent payments. More specifically, the intelligence, control, and authorization infrastructure connecting AI agents to money.

RobotMoney gives developers a policy and audit layer for agent spending. Your agent can ask whether a payment, ERP action, or customer-owned rail movement is allowed, and RobotMoney returns a recorded decision with checks, reason codes, and proof hooks.

RobotMoney holds neither funds nor rail access. It sits between an account holder and their financial world as the structured intelligence layer: ingest, normalize, remember, govern, execute, prove.

RobotMoney does not manage your agents, it governs how they use money.

How RobotMoney Is Organized

RobotMoney is a layered protocol; information flows up and control flows down.

Layer	Job
Raw	Lossless ingestion from any authorized source
Ledger	Deterministic normalization into immutable financial truth
Wiki	Continuously updated memory and natural-language Q and A
Policy	Plain-English rules compiled to deterministic guards
Agent	Internal and external agents proposing actions in scope
Audit	Per-tenant Merkle tree anchored on Base L2

Reads are grounded in evidence, writes emit audit events, and any financial action has to pass a deterministic pre-execution gate before it leaves the system. Nothing executes outside that gate.

What RobotMoney Is Not

RobotMoney is not a bank, a custodian, an accounting tool, an agent marketplace, or a generic assistant. Funds and custody belong to the account holder. RobotMoney reads, reasons, governs, and proves; it does not own the assets it operates on.

A First Integration

Important: RobotMoney, formerly RobotMoney, continues to run on the existing RobotMoney Core infrastructure while we complete the branding migration.

import { Brain } from "@braindotfi/brain-core-sdk";

const agent = new Brain({
  agentApiKey: process.env.BRAIN_AGENT_API_KEY!,
  environment: "sandbox",
});

const decision = await agent.authorizations.create({
  idempotencyKey: crypto.randomUUID(),
  execution: "external",
  action_type: "ach_outbound",
  amount: "100.00",
  currency: "USD",
  destination_counterparty_id: "cp_vendor",
  reference: "inv-first-001",
});

console.log(decision.decision, decision.reason_code);

invoice_id links a RobotMoney Ledger invoice and requires attached invoice evidence; for your own invoice number use reference.

That is the launch path: your agent asks for a recorded decision before your own rail moves money. No on-chain knowledge is required.

Staging / controlled pilot. Autonomous execution and on-chain proof are wired end-to-end, but RobotMoney runs on Base Sepolia behind smart contracts pending an external audit; a brain_sk_live_ key uses the same code path yet does not move real money on mainnet today. See the Readiness Summary.

Quickstart

Five minutes from npm install to a working integration.

Quickstart

Build

Task-shaped guides. The patterns most apps need in their first hour.

Platform Guides

Concepts

The mental model. Memory, policy, agents, proof.

Overview

Protocol

The deep stack. Six layers, smart contracts, on-chain anchoring.

Overview

Who RobotMoney Is For

You're building	You use RobotMoney to
A B2B finance product	Skip the integrations layer. Read normalized financial truth across every source
An autonomous agent for a business	Give it grounded memory, scoped permissions, and a provable audit trail
A fintech embedding into an ERP	Ship policy-gated actions on top of existing customer data, no schema rewrites
A treasury or operations dashboard	Query the tenant's full money picture in natural language or structured calls
An external agent marketplace	Plug into RobotMoney's MCP surface. Same primitives, same audit semantics

What You Can Build

In an afternoon	What it looks like
A finance copilot	Ask natural-language questions about a tenant's money; get answers with citations
A spending agent	Let an autonomous agent pay invoices under a limit; anything bigger goes to a human
An ops dashboard	Read transactions, balances, obligations, and counterparties from one feed
An external agent integration	Plug into any MCP-compatible runtime; full read and propose surface
A compliance trail	Every read, every decision, every action, exportable as a tamper-evident log

What RobotMoney Handles for You

You don't write	Because RobotMoney handles
Bank, ERP, and on-chain integrations	Source ingestion across Plaid, NetSuite, Alchemy, Stripe, and more
A memory layer for your agent	A continuously updated record per tenant, queryable in natural language
A permissioning DSL	Plain-English policies compiled to deterministic rules, signed by the tenant
A safe execution path	A deterministic gate that checks every payment before it leaves
An audit trail your customers can verify	A Merkle-anchored history on Base L2

Integration Surfaces

RobotMoney exposes four surfaces. Pick whichever matches your stack. They share the same data, the same policy, and the same audit log.

Surface	Best for	Reference
TypeScript SDK	Web apps, agent runtimes, internal tools	SDK quickstart
HTTP API	Any language, server-side integrations, custom workflows	API reference
MCP server	Third-party agents over the Model Context Protocol	MCP server
Smart contracts	On-chain settlement, programmable accounts, scope attests	Smart contracts

A First Request

npm install @braindotfi/brain-core-sdk

import { Brain } from "@braindotfi/brain-core-sdk";

const agent = new Brain({
  agentApiKey: process.env.BRAIN_AGENT_API_KEY!,
  environment: "sandbox",
});

const decision = await agent.authorizations.create({
  idempotencyKey: crypto.randomUUID(),
  execution: "external",
  action_type: "ach_outbound",
  amount: "100.00",
  currency: "USD",
  destination_counterparty_id: "cp_vendor",
});

console.log(decision.authorization_id, decision.decision);

The full SDK surface is documented in the API reference. For raw HTTP access, see Authentication.

Next Steps

• Build it: Quickstart, then the task-shaped guides.

• Understand it: Concepts, then Protocol.

• Integrate an external agent: MCP server.

• Verify a payment on-chain: Smart contracts and BrainAuditAnchor.

• Review the safety model: SECURITY.md. The §6 gate, layer boundaries, audit verification, and threat model.

Summary

RobotMoney in one page:

• What it is. Governance infrastructure for agent spending. RobotMoney lets a tenant create an agent, grant propose-only credentials, set policy and headless limits, and receive recorded decisions before money moves on the tenant's own rail.

• What it is not. It never holds funds or rail access. Custody stays with the account holder; RobotMoney reads, reasons, governs, and proves.

• How actions stay safe. Agents are propose-only. Decision-only authorizations create no PaymentIntent and move no money. Executed money movement, when enabled, still passes the tenant's signed policy and the deterministic pre-execution gate, and higher-risk rails require a recorded human approval from an authorized tenant member.

• How records stay grounded. Ledger, Wiki, Policy and Agent surfaces cite tenant-scoped evidence where they read tenant data, and exact financial questions are answered from deterministic Ledger queries rather than generated text.

• How it is proved. Every read, decision, and action emits an audit event into a per-tenant hash chain, and production tenants have their Merkle roots anchored on Base L2.

• How you integrate. Choose the TypeScript SDK, the HTTP API, the MCP server, or the smart contracts. All four share the same data, policy, and audit log.

• Where it stands today. Staging and controlled pilot on Base Sepolia, with mainnet anchoring fenced until the external contract audit completes. See the Readiness Summary.