> ## Documentation Index
> Fetch the complete documentation index at: https://docs.atum.xyz/llms.txt
> Use this file to discover all available pages before exploring further.
# Agentic payouts
> Atum is the payment tool your agent calls when a decision requires funds to move — what the agent decides, and what still has to be signed.
## Overview
Your AI agent resolves a task and needs to pay someone as part of that resolution — a contractor, a service, a counterparty. The agent makes that decision without a person in the loop, and it doesn't need to know which rail the recipient is on. Atum is the payment tool your agent calls.
Every payment still moves on a signature over that specific request. The agent decides; a signature authorizes. Where that signing key lives is the design decision on this page — see [Who signs](#who-signs).
LLM-powered systems where payment is a step in an autonomous decision loop.
Payment actions alongside other tool calls — web search, data lookup, contract execution.
Moving toward autonomous disbursement where the system decides when and how much to pay.
## Problem space
Atum solves:
* Rail and wallet complexity — agents shouldn't need to know which network a recipient is on
* Retry safety — idempotent tool calls prevent duplicate payments when agents retry
* Audit trail — structured receipts per payment, not raw transaction references
* Settlement blocking — asynchronous settlement so agents don't stall waiting for confirmation
## How it works
Your agent reaches a decision that requires payment and calls Atum as a tool — specifying recipient, amount, source token, and destination token. Atum routes it to the right settlement provider that moves the funds, then returns a structured receipt the agent can log and act on.
This is for payouts your agent *decides* to make through Atum's own SDK/CLI. If your agent instead needs to **pay for an HTTP-gated resource or tool call** — e.g. it hits a `402 Payment Required` from another service — see [Facilitated payments (x402)](/payment-protocols/x402/overview) or [Direct payments (MPP)](/payment-protocols/mpp/overview) instead, depending on which protocol the resource speaks.
## Who signs
The agent decides *whether* to pay. A signature over that request is what releases the funds. There are two ways to arrange that, and they are not equivalent.
| | The agent holds the signing key | The agent acts for a principal |
| ------------------------- | ------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------- |
| How a payment gets signed | The agent signs and submits on its own | The agent assembles the request; the principal's signer completes it |
| What the agent is | Whoever holds that key **is** that participant — the agent is not distinguishable from you | Software with a signed [delegation grant](/get-started/identity/know-your-agent#two-signed-grants) saying what it may do for whom |
| Limits | Whatever that key can spend | Corridors, assets, and limits named in the grant |
| Today | This is what the examples and the CLI do | [Know Your Agent](/get-started/identity/know-your-agent) — prepare-only, and not a self-serve integration |
If your agent holds the key, treat it like any other production signer: a testnet-only wallet while you build, and a scope you are willing to lose. The agent inherits everything that key can do.
If you need to establish **who is answerable** when the software spends — rather than letting the agent act as you — that is [Know Your Agent](/get-started/identity/know-your-agent). It is a separate question from identity on a payment ([Atum ID](/get-started/identity/overview)) and from permission to move funds.
## Shared responsibility
Atum handles payment execution — your agent handles the decision and the receipt.
| AI agent | Atum |
| ------------------------------------------------------ | -------------------------------------- |
| Make the payment decision (who, how much, which token) | Route to the right settlement provider |
| Call Atum with a signed, idempotent payment request | Move funds to the recipient's rail |
| Log the receipt and continue the workflow | Return a structured settlement receipt |
## Try it
Send a payment from your terminal in minutes
Add Atum to your agent's tool layer
## Next steps
* [Build with the SDK](/get-started/start-building/build-with-the-sdk) — integrate Atum into your agent's tool layer
* [Using the CLI](/get-started/start-building/using-the-cli) — send a first payment end to end
* [Know Your Agent](/get-started/identity/know-your-agent) — who is answerable when software spends
* [Payouts](/get-started/use-cases/payouts) — human or batch-triggered payouts
* [Atum payment lifecycle](/get-started/overview/how-an-atum-payment-works) — from request to confirmation
* [Facilitated payments (x402)](/payment-protocols/x402/overview) — when your agent is the one paying for a gated resource speaking x402
* [Direct payments (MPP)](/payment-protocols/mpp/overview) — same, for resources speaking MPP