Build agents that you can trust with money.
Give your agents a scoped authority before acting, and view what it did after, verifiable by any counterparty. You own your agents, Dace provides the trust.
DC · 2026 · 4471 · 0A7F
An agent that moves money is only as good as what it can prove.
Hand an agent your rails and it can pay the right supplier, the right amount, against the right invoice, into an unverified account. Now there is a paid invoice, a botched transfer, and a blame game over who authorized it. Every agent built on Dace gets three things that stop that from happening.
A scoped mandate before the agent moves: limits, approved payees, policy, approval thresholds. Authority it was never granted isn't there to use.
Without it: nothing caps what the agent can do. No limits, no approvals, no boundary on the blast radius.
Every action is checked against the mandate as it happens. In scope, it proceeds. Out of scope, it stops or escalates to a human.
Without it: a payment can clear and still be wrong. Wrong payee, wrong amount, right amount to the wrong account. Nothing checked the action against the intent.
Dace reconciles three records that don't otherwise meet: the authorization, the agent's report, and the settlement, then seals a portable Trust Certificate. Every mis-buy becomes an evidence review.
Without it: no neutral record of who authorized what, under which policy. Liability has nowhere to land.
One certificate. Every counterparty. Any rail.
Composable is table stakes. Provable is ours.
Portable
Verify it with a public key. No access to our systems, your data, or the agent's reasoning needed.
Neutral
Reconciled against settlement records we don't author. With no stake in the outcome, both sides of a dispute can accept it.
Cross-rail
One schema across every provider you connect, not a log trapped in one platform's book. A record on one network usually means nothing on another. This one holds.
We connect the money. We never hold it.
Dace orchestrates the providers you choose and proves what happened on them. No custody of funds, no agents of our own. A referee can't also be a player, and that neutrality is what makes one certificate credible to every party in a dispute.
Money movement is a dozen integrations. Dace makes it one.
Making an agent that can pay means wiring up a stack of integrations across rails, cards, checkout, approvals, among others. Dace collapses that into one connection.
- + wire up a PSP and a wallet provider
- + build agent identity and attestation
- + hand-roll spend limits and approvals
- + reconcile every action against intent
- + maintain it all as rails change
- ✓ one interface over your providers
- ✓ mandate, identity, approvals built in
- ✓ a signed Trust Certificate per transaction
import { Dace } from "@dace/sdk";
// Connect the rails you already use.
// Dace orchestrates them and never holds funds.
const dace = new Dace({ provider: "stripe" });
// Give the agent a scoped mandate. The gate.
const agent = dace.agent("ap-payer", {
mandate: {
limit: "$500k / run",
payees: "approved-vendors",
approval: "> $50k",
},
});
// It acts. Dace checks each action, seals proof.
const { paid, certificate } = await agent.pay(invoice);
// certificate → portable, signed, verifiableStart where the money is hard to unwind.
The same primitive holds anywhere authority is delegated across a boundary and someone has to prove what happened.
Built by people with deep expertise in payments, AI, and platforms.
previously at
Build agents that move money. Trust built in.
We're working with a small number of design partners building agents that move real money. Tell us what you're building — we'll be in touch.
Thanks — you're on the list.
We'll reach out at the email you gave. Talk soon.