DeFi agent with Privy and AgentKit

The mandate demo connects a Privy embedded wallet to an OpenAI agent built with Coinbase AgentKit. The owner approves recipients, transfer limits, a total budget, expiry, and gas reimbursement limits in their wallet. The agent can then request USDC transfers from that same account. GOL checks each request against the owner’s on-chain mandate.

Open the demo

Explore the deployed Base Sepolia application.

Browse the source

Read the Next.js application, its GOL integration, and its tests.

This example uses the Base Sepolia testnet, the GOL version 3 core, hosted API 0.5.0, and @gol/sdk@0.5.0. The application is a demonstration, not an audited or mainnet product. The availability page defines the exact supported account configurations and limits.

How it works

The account remains the owner’s EOA. GOL’s reviewed EIP-7702 setup delegates it to Biconomy Nexus 1.3.3 and installs the GOL core. Privy holds the owner key and presents the owner’s signing requests. The demo server holds a separate, unfunded agent signer and a scoped GOL test API key. GOL’s relayer submits agent actions and receives network gas reimbursement in the same transaction, within the owner’s signed caps. The agent signer never pays gas or receives the owner’s funds.

Part	Responsibility in this example
Privy	Authenticate the owner, provide the embedded EOA, and sign owner approvals and EIP-7702 authorization.
Next.js server	Verify the Privy session and linked account, keep the GOL API key and agent key server-side, and call the public GOL API.
OpenAI and Coinbase AgentKit	Interpret a request and invoke the demo’s `transfer_usdc` tool. AgentKit’s built-in transfer tools are not registered.
GOL SDK and API	Prepare and verify owner payloads, prepare agent actions, relay transactions, and report execution state.
GOL core on Base Sepolia	Enforce the mandate and gas policy on every agent action, independently of the model or demo server.

Code highlights

These excerpts point to the complete source. They show integration boundaries; the repository contains the surrounding authentication, error handling, polling, and UI code.

Bind the owner’s wallet before signing

Privy can have more than one linked wallet. The demo binds its EIP-7702 signer to the EOA being set up, and the SDK verifies that the authorization and initialization signatures recover to that account. A signature from another linked wallet is refused before submission.

// lib/privy-signers.ts
export function boundPrivyAuthorization(signAuthorization, account) {
  return (input) => signAuthorization(input, { address: account });
}

// app/page.tsx
const body = await signPreparedEip7702Setup(
  { authorization: ownerAuthorizationSigner, initialization: ownerRawHashSigner },
  prepared,
  { account },
);

See the Privy signer adapter and owner flow. The second call above is abbreviated; the application builds those signer adapters from the active Privy wallet.

Turn the owner’s choices into a mandate

The owner enters 1 to 16 payees, a maximum per transfer, a lifetime total, and gas limits. Only payee addresses become authority. Names remain local labels for the agent interface. The server prepares a policy, and the browser asks the owner to sign only after the SDK checks the prepared payload against the form values.

// app/page.tsx, abbreviated
const prepared = await golPost("/api/gol/prepare-policy", formToRequest(values, account, agent));
const call = await signPreparedGasPolicy(ownerSigner, prepared, {
  agent,
  recipients: values.contacts.map((contact) => contact.address),
  maxPerActionBaseUnits: BigInt(values.maxPerActionBaseUnits),
  maxTotalBaseUnits: BigInt(values.maxTotalBaseUnits),
  maxGasPerActionWei: BigInt(values.maxPerActionWei),
  maxGasTotalWei: BigInt(values.maxTotalWei),
  chargeableOutcomesMask: values.chargeableOutcomesMask,
  relayer: { mode: "gol" },
});

The owner sends the approval transaction and pays its network gas. The agent cannot create or widen that approval with the GOL API key. See policy preparation, owner signing, and the hosted gas guide.

Give AgentKit one payment path

The demo registers one custom GOL action provider. The model chooses a payee name and an amount; code resolves the name to an address, parses the amount in USDC base units, and asks GOL to prepare the action. The agent signs the prepared action and its maximum network charge before submission.

// lib/server/gol-action-provider.ts, abbreviated
const payee = resolveForAgent(binding.contacts, to);
if (!isResolved(payee)) return JSON.stringify({ ok: false, message: payee.message });

const actionId = newActionId();
const prepared = await gol.prepareGasExecution(projectId, actionId, {
  mandateId: binding.mandateId,
  gasPolicyId: binding.gasPolicyId,
  recipient: payee.address,
  amountBaseUnits: amount.toString(),
  deadline,
});
const signed = await signPreparedGasExecution(agentSigner, prepared, {
  maxChargeWei: serverEnv.agentMaxChargeWei,
});
const execution = await gol.submitGasExecution(projectId, actionId, signed);

actionId is the idempotency key. If a submission times out, the demo looks up that ID before reporting its outcome, because the transaction may already have been sent. An unknown payee name is stopped by name resolution. A valid address outside the owner’s allowlist can reach the core, which refuses it on-chain. See the action provider and AgentKit registration.

Show API state beside chain evidence

The proof panel fetches GOL’s execution details and independently reads the transaction receipt from public Base Sepolia RPC. It decodes the core’s execution or refusal event, USDC Transfer, and inline GasSettled event. It displays the two views together and flags a disagreement. A receipt can appear before GOL confirms the action at Base’s safe head; safe is not Ethereum finality. The example’s live test verified one owner approval and one 0.1 USDC agent transfer with on-chain MandateActionExecuted, USDC Transfer, and GasSettled events. The demo’s owner-specific on-chain refusal and delegation-reset paths have not been verified live. The receipt decoder tests cover a recorded transfer and a refusal fixture. The Vercel site and its unauthenticated API guards have been checked. An authenticated run at the hosted origin is pending confirmation of that domain in the Privy app settings.

Use the pattern with another stack

GOL’s authority is the owner-signed policy and the compatible account’s on-chain enforcement. Privy, Next.js, AgentKit, and OpenAI are application choices in this example. A different stack can use the same public API and SDK if it supplies the required signing and account behavior.

Replace	Keep the GOL integration contract
Privy with another wallet provider	The owner wallet must sign the exact payload for an actively supported account configuration. EIP-7702 setup also needs the owner authorization and raw-hash signature the SDK verifies.
AgentKit or OpenAI with another agent runtime	Give the runtime a tool that calls `prepareGasExecution`, signs the prepared action with the mandate’s agent signer, and calls `submitGasExecution`. The model does not enforce the mandate.
Next.js with another server framework	Keep the project API key and agent signer on the server, authenticate each user, and call `@gol/sdk/server` or the public HTTP API.
The demo’s polling UI with another interface	Read execution state through the API or signed webhooks, and use the transaction receipt when you need independent chain evidence.

Account support is specific to reviewed implementations and configurations; a wallet provider alone does not make an account compatible. Integrate hosted gas covers the complete supported flow beyond this application example.

Run the example

Clone the repository, use Node.js 22 or later and pnpm 11, and follow its setup guide. You need a Privy app with an embedded EOA, a GOL test project with a scoped key, an OpenAI API key, and an agent signing key. The owner needs Base Sepolia ETH for the approval and inline gas reimbursement, plus testnet USDC for transfers. Keep the GOL and OpenAI keys and the agent key server-side; the owner key stays in their wallet.

pnpm install
cp .env.example .env.local
pnpm key:agent
pnpm check:env --write
pnpm dev

The demo asks the owner to configure payees and limits, approve the mandate, and then visit /agent. Owner pause, resume, and revocation are separate wallet actions and require no cooperation from the agent.

Open the demo

Browse the source

​How it works

​Code highlights

​Bind the owner’s wallet before signing

​Turn the owner’s choices into a mandate

​Give AgentKit one payment path

​Show API state beside chain evidence

​Use the pattern with another stack

​Run the example