Let agents move money, without losing control.
Dakota is the regulated money-movement platform built for AI agents. Human-signed mandates, policy enforced in the infrastructure, and every action attributed. Ship in days.
agent, _ := dakota.Agents.Create(ctx, &dakota.AgentInput{ Name: "AP Bot", CustomerID: "cust_2abc...", }) agent.SubmitIntent(ctx, "Pay Verizon $255/mo")
How Dakota thinks about agentic payments.
Three principles that shape everything underneath.
Built for agents
Agents are economic actors that need infrastructure built for them, not retrofitted around them. The old payment stack assumed a human at a keyboard.
Full parity with humans
Agents are first-class citizens with the same surface humans have. Anything a human can do in Dakota, an agent can do too.
Policy in the infrastructure
Policy lives in the infrastructure. Enforced at the wallet and ledger level, it cannot be jailbroken, prompt-injected, or hallucinated around.
Four building blocks. One regulated agentic payments platform.
The primitives every agent needs to move money safely.
Mandates
Bind agents to a human-signed mandate: which recipients, how much, how often. Dakota verifies the signature on every transaction and enforces it.
Intents
Turn a prompt, PDF, email, or invoice into structured, confirmable actions. The agent proposes, an authorized user confirms, Dakota executes. Each step is a real API call.
Hosted agents
Connect your own agent, or drop in a Dakota-hosted one. Ship agent features without building, hosting, or operating an agent yourself.
AI insights
An agent watches activity continuously and surfaces missed payments, duplicates, fraud signals, and cashflow risks. It informs, it never moves money on its own.
Create an agent. Sign a mandate. Let it run.
From provisioning to autonomous, audited money movement.
Create an agent
Provision an agent with its own cryptographic identity. It signs every transaction it submits, so each action is bound to a signer Dakota can verify.
Sign a mandate
A human signs a mandate scoping what the agent can do. Which recipients, how much, how often. Nothing moves outside that scope.
Let it run
The agent moves money within its mandate and your policies. Every action is attributed to the agent and audit-ready for regulators.
See it in action: AI bill pay.
One use case that exercises all four building blocks at once.
A neobank drops Dakota bill pay into their app, fully white-labeled. Their customer forwards an invoice, and the agent takes it from there. Integration takes about an hour.
- Reads the invoice and drafts the payment (Intents)
- Pays within a human-signed mandate (Mandates)
- Runs hosted on Dakota infrastructure (Hosted agents)
- Flags duplicates and cashflow risk (AI insights)
// Extract intents from an invoice, execute on approval. res, _ := dakota.Intents.Create(ctx, &dakota.IntentInput{ AgentID: "agt_2abc...", Source: invoice, }) // res.Intents includes CreateRecipient + ScheduleTransaction dakota.Intents.Approve(ctx, res.ExtractionID)
Regulated agent payment infrastructure, not a software wrapper.
A pure-software agent stack still has to answer for custody, compliance, and rails. Dakota already does.
Regulated execution
Agents move money on regulated rails. Dakota is registered in the US as a FinCEN MSB with state money transmitter licenses, and EU licensing is underway.
Multi-rail, one API
Orchestrate ACH, Fedwire, SWIFT, and SEPA alongside stablecoins on EVM and Solana, plus DKUSD issuance. An authorized user sets the destination — rail, asset, and chain — in the mandate, so every payment moves exactly where it's authorized.
Custody you can trust
Non-custodial wallets with a KMS-signed, Merkle-rooted policy engine. The same infrastructure already moving billions of dollars for businesses.
Questions before you build.
An agentic payments platform is the regulated infrastructure that lets AI agents move money within user-signed mandates, with policy enforced at the wallet and ledger level. Dakota provides it across fiat and stablecoin rails, with every action attributed and audit-ready.