Valto — The decision engine for agent spending

The problem

“Can pay” is not “should pay”

Payment rails can verify that a transaction is authorized and within a limit. They do not know whether the purchase is useful, whether the provider has performed well before, or whether a better option exists.

That becomes a problem when software can make thousands of small purchases without a human reviewing each one.

Valto turns every proposed spend into a decision request: what the agent wants to buy, why it wants it, the price, the provider, the budget, and the relevant history.

Prompts can advise the agent. Valto can enforce the decision.

Approve Deny Suggest Escalate

How it works

Valto sits between intent and any action that costs money

The agent proposes a paid action. Valto evaluates the intent, price, budget, provider history, and prior outcomes before the action executes.

Valto does not hold funds or replace the payment rail. It returns a verdict, records why the decision was made, and later attaches the result.

agent intent → evaluate (price · budget · history · outcomes) → verdict → paid action

Proof

The policy helped most when the agent did worst

I tested Valto in a simulated pay-per-call marketplace with four vendors, a fixed budget, and one provider that claimed 99% accuracy but delivered roughly 12%.

Valto first observed the agent’s purchases and outcomes. It then enforced a small policy learned from that history across the same eight matched environments.

The agent was not retrained or reprompted. Only the policy changed.

+19%average profit

−52%wasted spend

+56%worst observed result

Average profit increased 19%, wasted spend fell 52%, and the worst observed result improved 56%.

Profit per episode across eight paired simulation worlds, with and without a Valto policy.

The result is early evidence that outcome-linked policy can improve agent spending. It is not yet a production ROI claim.

Read the experiment.

Controlled simulation: eight paired worlds, one model and one reasoning setting.

The product today

A working Python SDK

pip install valto

The current product is a Python SDK that runs embedded in your application or as a local service. It does not hold funds or execute payments. Your application remains responsible for the actual action.

Wrap a paid action. If the verdict is deny, the function does not run.

from valto import Valto

valto = Valto.local(actor="research-agent")  # embedded engine, no server needed

@valto.protected(
    action="buy_market_data",
    amount=1.50,
    payee="market-data-api.com",
    intent=lambda query: f"Buy market data for: {query}",
)
def buy_market_data(query: str):
    return market_data_api.buy(query)  # runs only if approved

Or call the decision loop directly, execute through your own rail, and report the outcome.

decision = valto.decide(
    action="buy_market_data",
    amount=0.25,
    payee="market-data-api.com",
    intent="Buy market data for the current task",
)

if decision.verdict == "approve":
    receipt = buy_the_data()
    valto.report(decision.id, executed=True,
                 result_summary="data improved the final answer")

Every proposal, verdict, execution, and outcome lands in the same ledger. The agent does not need to be retrained.

propose → decide → execute → report outcome → revise policy

View the package and installation details on PyPI.

Payment rails

Works above any payment rail

Agents can pay through x402, Circle wallets, cards, platform credits, and other systems. Valto sits before the payment step.

The rail handles authorization and settlement. Valto evaluates whether the proposed action makes sense, records the decision, and connects the eventual receipt and outcome back to the original intent.

I have also built a small integration proof using Base Sepolia and Circle. The goal is one decision history across multiple agents and rails.

x402 Circle wallets USDC Cards API credits SaaS billing

Product direction

The long-term idea: persistent economic memory for agents

A payment record shows that money moved. It usually does not show what the agent was trying to accomplish, what alternatives it considered, why the action was approved, or whether the purchase was useful.

Valto’s long-term value may come from preserving that context over time.

1 · Decide

Return a verdict before the agent commits money or budget.

2 · Learn

Connect each decision to its result and build a measured history of agents, providers, and actions.

3 · Score

Use repeated outcomes to estimate provider quality, transaction risk, and the level of authority an agent has earned.

Decisioning is the product today. The more interesting long-term asset is the outcome-linked ledger.

If agents eventually control larger budgets, that history could support better limits, counterparty scores, pricing, guarantees, and other financial products. The immediate focus is proving the decision layer before expanding into those markets.

Agents will need more than wallets. They will need memory, policy, and accountability.
Valto is an early attempt to build that layer.