How to Assign Accountability for Every Automatic Payment in a Multi-Person Agent Account

You know who spent the money, but you do not know who told the agent to spend it. That is the hardest part of holding people accountable when multiple people manage one agent account. Accountability is not about who clicked a button. It is about whose authorization allowed the transaction to happen.

Concept Breakdown: What the "Decision Chain" Looks Like in an Agent Account

A normal multisig wallet has simple accountability: whoever signs is responsible. But in an agent account, the agent spends the money. The person who decides how it spends may be anyone: someone who writes prompts, someone who sets strategy, or even a web page that was scraped.

If you treat the signature as the only evidence, you will never find the responsible person. The right way to trace accountability is to split every automatic payment into three parts:

1. Who allowed the agent to spend this way? — Strategy configuration (limits, whitelist, time window)

2. Who triggered this action? — Input data or instruction

3. Who executed the signature? — The agent's own private key or session key

Accountability means checking whether there is any sign of tampering between the first part and the third part, not just looking at the signature.

Comparing Options: Trade-offs of Three Accountability Methods

How to Do It: A Practical Accountability Framework

Step 1: Turn On Hash-Chain Audit Logs

[What to do] Make each operation record tamper-proof, without relying on manual screenshots or Excel.

[How to do it] Use a tool that supports hash-chain audit logs, such as Stellar Agent Wallet. Every tool call, policy change, and payment authorization is recorded as a JSONL entry. It includes the timestamp, tool name, policy decision (allow or deny), and the hash of the previous record.

The log format looks like this:

{
"ts": "2026-08-13T10:35:00Z",
"tool": "x402_payment_authorized",
"policy_decision": "allow",
"prev_hash": "0x7a3f...",
"hash": "0x9c2e..."
}

[Completion standard] Run the audit verify command. It returns chain intact with no breaks or HMAC mismatch warnings.

Step 2: Record "Who Authorized This Use of Funds"

[What to do] Link each payment to "who allowed the agent to spend this way," not just to who signed.

[How to do it]

• Use a policy engine like @t402/agent-policy. In the authorization flow, inject principal (the authorizer) and delegate (the agent) identifiers.

• Record policy changes themselves: who changed what rule, and when.

[Completion standard] In every payment audit record, you can trace the matching principal, not just the delegate.

Step 3: Add Human Confirmation for High-Value Payments

[What to do] For payments above a threshold, the system does not sign automatically. It waits for a real person to approve.

[How to do it] Use the approval flow in @t402/agent-policy. Set requiredApprovers in the policy. When a payment exceeds the threshold, the system creates a pending approval record and sends a notification to the specified email addresses.

policy: {
spendingLimits: {
perTransaction: { value: '100000000', decimals: 6, symbol: 'USDT' },
daily: { value: '500000000', decimals: 6, symbol: 'USDT' }
},
approvalThresholds: {
perTransaction: { value: '50000000', decimals: 6, symbol: 'USDT' },
requiredApprovers: ["This email address is being protected from spambots. You need JavaScript enabled to view it.", "This email address is being protected from spambots. You need JavaScript enabled to view it."]
}
}

[Completion standard] For payments above the threshold, the log shows an approval.created event. Execution only continues after a real person approves.

Common Reasons for Failure

1. Logs only record the transaction hash, not the policy decision reason. A block explorer can only tell you where the money went. It cannot tell you why the agent started the transaction. Logs without policy_decision and reason fields are almost useless for accountability.

2. Multiple people share the same agent session. If three people use the same delegate identity to operate the agent, all operations appear in the audit log as coming from the same signer. You cannot tell who is who.

3. Policy changes leave no audit trail. If someone quietly changes the daily limit from 100 USDT to 10,000 USDT, and then the agent spends a large amount, the payment record only shows "limit sufficient." You cannot see who changed the limit.

Important warning: Regulators have already made it clear that even if a payment is initiated by an agent, the account holder has final responsibility for that payment. Multisig and audit logs are not meant to help you avoid responsibility. They help you quickly find where the problem happened, who changed what, and who should be held responsible when something goes wrong. Without a verifiable evidence chain, all responsibility will ultimately fall on the account holder.

Final Verification

Run a complete accountability test:

1. Ask a team member to start a payment through the agent.

2. After the agent executes it, export the audit log.

3. Find that payment in the log and confirm you can find:

   • Who initiated the instruction (principal)

   • Which agent executed it (delegate)

   • The policy decision result (policy_decision)

   • The hash of the previous record, so you can verify the chain is intact

Verification channel: Run audit verify. The chain should pass. The log should answer two questions: "Who told the agent to spend this money?" and "Why was the agent allowed to spend it this way?" If you cannot answer those questions, go back and add policy decision records or principal identifiers.