Artificial intelligence

When AI Agents Can Spend Money, Execution Needs a Paper Trail

Written by
Read time
6 min
Published
Add to Preferred Sources
When AI Agents Can Spend Money, Execution Needs a Paper Trail

An AI agent that summarizes a document can be wrong without changing the outside world. An agent that sends that document somewhere, incurs a charge, and creates a delivery record is different. The engineering question is whether the system can prove the action was authorized.

Fax makes this distinction unusually clear. Every send has a document, a destination, a sender, a price, and an outcome that someone may later need to establish. That makes fax a useful case study for consequential automation. A delivery receipt is not merely an interface detail; it may matter during a later dispute.

Treat the Model as a Requester, Not an Approver

Language models are good at interpreting intent. They are not a safe place to store spending limits or approval rules. A prompt saying “never spend more than the budget” is guidance, not enforcement. Another prompt, a retrieved document, or a convincing instruction in an email can conflict with it.

The durable design is to enforce permissions on the server. The server checks identity, allowed actions, approvals, and available budget before any paid operation proceeds. The model can request an action and explain why it seems appropriate, but it cannot grant itself broader authority by changing the words in its context.

This separation assigns responsibility. Product owners define what users may authorize. Engineering teams implement the checks. The agent supplies proposed inputs. No persuasive generated text should collapse those boundaries.

A Quote Is More Than a Price Estimate

A quote is useful only when it describes the exact action that will be executed. Consider an agent preparing to fax a signed agreement. If the destination changes after a user approves the estimated cost, the user has not necessarily approved the new transaction. The same problem appears when a file is replaced, even if its filename remains unchanged.

In the Fax for Agents workflow, a quote binds the document, destination, sender, and amount for ten minutes. Approval is similarly specific: it covers one document hash, one destination, one sender, one amount, and an expiry.

The document hash matters because filenames and descriptions are weak identifiers. Two files can share a name while containing different terms. If even part of the approved document changes, the existing approval is invalid rather than transferable. That prevents an agent, or an upstream workflow, from treating consent for one file as consent for another.

For product teams, the practical lesson is to design approval screens around the actual transaction. Show the recipient, sender, document identity, and expected cost. For engineering teams, ensure the backend compares those approved values with the execution request instead of trusting a summary returned by the model.

Retries Must Not Become Duplicate Charges

Agents retry. They time out, lose connections, misunderstand responses, and reenter the same step after a workflow resumes. A human sees one task, while the underlying system may make several calls. For an action that sends a document and charges money, that mismatch is dangerous.

An Idempotency-Key on every mutating call gives the system a stable way to recognize repetition. When the same operation is retried with its key, the response points to the same job rather than creating another fax. A retry now asks what happened rather than initiating another send.

Teams implementing tool orchestration should make key management part of workflow state, not an improvised string generated afresh on each attempt. Persist the key alongside the intended action. Reuse it when recovering from network uncertainty, and distinguish a genuinely new user request from a repeated attempt to complete the old one.

This principle applies well beyond faxing. Wherever an agent can trigger purchases, bookings, or paid external requests, retry safety belongs in the transaction design rather than in a hopeful instruction to the model.

Report What the System Knows, Not What It Hopes

A successful API call does not prove successful delivery. It might mean only that a job was accepted. This is where many automations produce misleading dashboards: they turn an intermediate acknowledgment into a final outcome.

A more honest job model uses six states:

  • queued: The job is waiting to run.
  • active: Processing is underway.
  • partial: Some, but not all, of the work succeeded.
  • failed: The attempt has failed.
  • unknown: The system lacks enough evidence to establish the outcome.
  • delivered: The provider supplied delivery evidence for the attempt.

The distinction between unknown and failed is particularly important. If an external provider never returns conclusive evidence, calling the job failed may be just as misleading as calling it delivered. An operator needs to know when the truth is unresolved, because blindly resending an unknown job could create the very duplicate the system was designed to avoid.

Delivery should therefore be a claim backed by evidence recorded on the attempt, not an optimistic inference from elapsed time or a generic success message. Good interfaces expose uncertainty clearly.

Incoming Documents Are an Injection Surface

Security reviews often focus on the prompt that starts an agent workflow. Yet the next document an agent reads may come from an outside party. A received fax could contain ordinary business information, but it could also contain text telling the agent to ignore previous instructions, change a destination, or initiate another paid action.

That text is data, not authority. Received fax content is marked as untrusted data in every result, a useful reminder that an incoming document must not rewrite the rules governing subsequent tool calls.

A practical implementation keeps document extraction separate from command execution. The agent can summarize what the fax says, classify it, or propose a response. Before any outbound action, the server still checks the requested parameters against permissions, budgets, and approvals. If the content suggests a new recipient or attachment, that becomes a proposed change requiring its own authorization.

The goal is not to make incoming text harmless. It is to ensure that untrusted text cannot quietly become an instruction with spending power.

Operational Details Belong in the Design Review

The surrounding API and commercial model shape the architecture, too. The service exposes 17 MCP tools at its MCP endpoint and a REST API with 146 operations across 18 groups, according to its October 29, 2026 OpenAPI 3.1 snapshot. MCP setup is documented for Claude Code, Claude Desktop, Cursor, Codex, and n8n.

For United States and Canadian traffic, sending costs $0.039 per page and receiving costs $0.019 per page. Numbers cost $2 per month, and the prepaid wallet has a $10 minimum top-up. A free sandbox requires no card, making it practical to test approval paths, retries, and failure handling before involving real charges.

Uploads accept PDF, PNG, JPG, and TIFF. Text, Markdown, and HTML can be rendered into PDF, but office formats are not supported. Signed webhooks use HMAC-SHA256 and an event ID, which gives integration teams material to authenticate notifications and recognize repeated events.

Documents are private, processed in the EU, retained for 30 days by default, and deletable by their owner. Those facts should inform retention decisions and support procedures, rather than being buried in integration notes.

Build for Evidence Before Autonomy

The appeal of agents is that they reduce manual steps. But removing a click does not remove the need for consent, accounting, or reliable records. It moves those responsibilities into system design.

A trustworthy action workflow can answer straightforward questions: Who authorized this exact operation? Which document and destination were covered? What amount was approved? Was a retry a new attempt or the same job? What evidence supports the reported outcome? And did any untrusted input attempt to steer execution?

If those answers live in server-enforced controls and durable records, an agent can be flexible without becoming unaccountable. That is the standard engineering teams should aim for whenever generated decisions become real transactions.

Spotted an error? Request a correction
Never miss a storyThe TechBullion Weekly newsletter and your preferred channels.Subscribe
Share this
Comment

More executive interviews

Founders, CEOs and technology leaders talk about what they build, how they fund it, and where AI, finance and data are taking their industries next.

All interviews