> For the complete documentation index, see [llms.txt](https://docs.robotmoney.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.robotmoney.com/introduction/readme.md).

# 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.

<table><thead><tr><th width="200">Layer</th><th>Job</th></tr></thead><tbody><tr><td>Raw</td><td>Lossless ingestion from any authorized source</td></tr><tr><td>Ledger</td><td>Deterministic normalization into immutable financial truth</td></tr><tr><td>Wiki</td><td>Continuously updated memory and natural-language Q and A</td></tr><tr><td>Policy</td><td>Plain-English rules compiled to deterministic guards</td></tr><tr><td>Agent</td><td>Internal and external agents proposing actions in scope</td></tr><tr><td>Audit</td><td>Per-tenant Merkle tree anchored on Base L2</td></tr></tbody></table>

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

{% hint style="warning" %}
**Important:** RobotMoney, formerly RobotMoney, continues to run on the existing RobotMoney Core infrastructure while we complete the branding migration.
{% endhint %}

```typescript
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](/architecture/readiness-summary.md).

<table data-view="cards"><thead><tr><th></th><th></th><th data-type="content-ref"></th><th data-hidden data-card-target data-type="content-ref"></th></tr></thead><tbody><tr><td><strong>Quickstart</strong></td><td>Five minutes from <code>npm install</code> to a working integration.</td><td><a href="/introduction/quickstart.md">Quickstart</a></td><td></td></tr><tr><td><strong>Build</strong></td><td>Task-shaped guides. The patterns most apps need in their first hour.</td><td><a href="/platform/overview.md">Platform Guides</a></td><td></td></tr><tr><td><strong>Concepts</strong></td><td>The mental model. Memory, policy, agents, proof.</td><td><a href="/concepts/overview.md">Overview</a></td><td></td></tr><tr><td><strong>Protocol</strong></td><td>The deep stack. Six layers, smart contracts, on-chain anchoring.</td><td><a href="/protocol/overview.md">Overview</a></td><td></td></tr></tbody></table>

## 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](/introduction/quickstart.md)   |
| HTTP API        | Any language, server-side integrations, custom workflows  | [API reference](/api-reference/overview.md)     |
| MCP server      | Third-party agents over the Model Context Protocol        | [MCP server](/mcp-server/overview.md)           |
| Smart contracts | On-chain settlement, programmable accounts, scope attests | [Smart contracts](/smart-contracts/overview.md) |

## A First Request

```bash
npm install @braindotfi/brain-core-sdk
```

```typescript
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](/api-reference/overview.md). For raw HTTP access, see [Authentication](/api-reference/authentication.md).

## Next Steps

* Build it: [Quickstart](/introduction/quickstart.md), then the [task-shaped guides](/platform/overview.md).
* Understand it: [Concepts](/concepts/overview.md), then [Protocol](/protocol/overview.md).
* Integrate an external agent: [MCP server](/mcp-server/overview.md).
* Verify a payment on-chain: [Smart contracts](/smart-contracts/overview.md) and [BrainAuditAnchor](/smart-contracts/brainauditanchor.md).
* Review the safety model: [SECURITY.md](https://github.com/braindotfi/brain-core/tree/main/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](/architecture/readiness-summary.md).