> ## Documentation Index
> Fetch the complete documentation index at: https://developers.fd.xyz/llms.txt
> Use this file to discover all available pages before exploring further.

# Trust & Constraints

> The 'pocket money' philosophy — sensible constraints for AI agent financial autonomy.

How much financial autonomy should you give an AI agent? The answer is simpler than most people think.

## The Pocket Money Philosophy

Think of funding an agent wallet like giving pocket money. You put in what's appropriate for the task — not your entire portfolio. The agent operates autonomously within that scope. If something goes wrong, you lose the pocket money, not everything.

This is deliberately simpler than:

* **Complex policy engines** that require extensive configuration before your agent can do anything
* **Role-based permission systems** that add integration overhead and maintenance burden
* **Multi-approval workflows** that defeat the purpose of autonomous operation

The constraint **is** the balance. If you fund a wallet with \$50, the worst case is losing \$50. No policy engine needed. No configuration. The constraint is immediate, obvious, and enforced by the blockchain itself.

<Tip>
  Don't give an agent more than you'd be comfortable losing. This one rule
  handles 90% of trust decisions.
</Tip>

## How to Think About Funding

**Start small.** Always. Fund what you need for the immediate task, see how the agent performs, and increase as you gain confidence.

**Match funding to the task.** A research agent that buys API access needs \$10–50. A trading agent running a strategy might need \$500. An enterprise payment agent might need more. Let the task dictate the amount.

**Refill rather than pre-fund.** It's better to add \$100 five times than to deposit \$500 upfront. Each refill is a checkpoint — a moment to review what the agent did with the previous funds.

## Setting Constraints

### Balance Is the Primary Constraint

The amount in the wallet is the most powerful constraint you have. It's:

* **Enforced by the blockchain** — the agent literally cannot spend more than what's in the wallet
* **Immediately effective** — no configuration, no policy language, no deployment
* **Transparent** — you can check the balance at any time via any block explorer
* **Universal** — works the same regardless of which interface the agent uses

### Progressive Trust

1. **Small real funds** — Fund with \$10–50. Verify the agent does what you expect.
2. **Working amount** — Once you trust the behavior, fund what the use case actually needs.
3. **Scale up** — Increase funding as the agent proves itself over time.

Each step is a conscious decision. There's no automation that escalates trust — you decide when to increase the balance.

## Trust Patterns by Use Case

| Use Case                       | Suggested Funding  | Constraints                               | Wallet Level  |
| ------------------------------ | ------------------ | ----------------------------------------- | ------------- |
| Testing and exploration        | Test tokens (free) | None — let it experiment                  | EOA           |
| Agent buying API access        | \$10–50            | Fund per session                          | EOA           |
| Bot making small purchases     | \$100–500          | Refill periodically                       | EOA           |
| Agent with recurring tasks     | \$500–2,000        | Review activity weekly                    | EOA           |
| Multi-agent deployment         | Per-agent budgets  | Individual funding per agent              | EOA           |
| Higher-value production        | Task-appropriate   | Consider Smart Account for added controls | Smart Account |
| Enterprise with approval needs | Custom             | Granular permissions, multi-party control | Delegated     |

Most entries in this table are EOA — because most agent use cases work perfectly with just sensible balance management.

## When Simple Constraints Aren't Enough

The pocket money approach works for the vast majority of use cases. But some scenarios call for more:

**You need batch transactions or gas abstraction** → [Smart Account](/agent-wallet/wallet-architecture#level-2-smart-account) adds programmable on-chain logic, session keys, and gas sponsorship.

**You need on-chain spending limits** → [Delegated wallet](/agent-wallet/wallet-architecture#level-3-delegated-wallet) adds granular spending controls enforced by the smart contract itself.

**You need multi-party approval** → Delegated wallets support approval workflows for high-value operations.

The key principle: don't over-engineer trust controls before you need them. Start with sensible funding. Upgrade only when the use case genuinely demands it.

## Common Mistakes

**Over-funding early.** Developers deposit large amounts "to avoid having to refill." This removes the natural safety net. Fund small, refill often.

**Over-engineering controls.** Building complex permission systems before you've validated the agent's behavior. Start with pocket money. Add controls when you have real data on what the agent does.

**Under-monitoring.** The pocket money approach doesn't mean "fund and forget." Check your wallet's on-chain activity periodically. Block explorers make this trivial.

**Treating all agents the same.** A research agent and a trading agent have very different risk profiles. Fund each according to its purpose, not with a blanket amount.