Give an agent a budget, not your credit card.

Teams running agents that already act on their own. If an agent of yours calls paid services, buys data, or is heading toward paying other agents, the finance question arrives before you are ready for it.

You probably recognise one of these:

• An agent holds a shared API key with no cap, and nobody is comfortable about it
• Every purchase waits for a human, which removes most of the reason to have an agent
• Someone in finance asked what the agents spent last month and the answer took two days
• You have twelve agents and one spending policy, applied by hope

• Identity.

  Its own name and keypair, not a shared credential pasted into a prompt. Actions belong to the agent that took them, and that record survives restarts, redeploys and model changes.

• A balance.

  Funded by you, spent as it works, and when it reaches zero the agent stops. The balance is the ceiling on what an agent can ever cost you through Operity.

• Limits.

  How much per transaction, per day, per month, and who it may pay. You set them. The agent cannot change them, and no instruction reaching it can.

• A record.

  Every movement, permanent, inspectable, exportable. When someone asks where the money went, the answer is a record rather than a reconstruction.

1. 01

   Create the agent.

   It gets an identity separate from your account and from every other agent you run.

2. 02

   Fund it.

   Move credit across. Top up or take back at any time.

3. 03

   Set the limits.

   Per transaction, per day, per month, and an allowlist of who it may pay.

4. 04

   Let it work.

   It pays as it goes. Anything outside the limits is refused before money moves.

5. 05

   See everything.

   Filter, review, attribute, export.

import osimport uuid import operity_client base_url = os.environ.get("OPERITY_BASE_URL", "https://operity.vercel.app")principal = operity_client.Principal(os.environ["OPERITY_API_KEY"], base_url=base_url) # The agent's own keypair. The private half never leaves this machine: the# agent signs every request with it, and the key you created above cannot act# as the agent. Keep keypair.seed_bytes() somewhere safe if you want the agent# back tomorrow.keypair = operity_client.Keypair.generate()record = principal.create_agent(f"quickstart-{uuid.uuid4().hex[:8]}", keypair) # Fund it with one test credit. The reference names the payment the credits# stand for; each reference is redeemable once.principal.fund(record.id, 1_000_000, reference=f"quickstart-{uuid.uuid4().hex}") # Now act AS the agent: a signed request, metered against its balance.agent = operity_client.Agent(record.id, keypair, base_url=base_url)before = agent.me().balance_ucresult = agent.action("retrieval")after = agent.me().balance_uc assert before - after == result.cost_uc > 0

• Today it is a test credit.

  A unit of account inside Operity. No payment provider is connected, so a balance does not yet correspond to money you have paid in.

• Funding and withdrawal are planned, not built.

  When they exist they will run through a regulated payment provider. None is confirmed, and we will name one here when that changes rather than before.

• It caps Operity-controlled spending only.

  Not your model tokens, not your cloud bill, not anything your agent pays for by another route.

• Stopping is not unwinding.

  An exhausted balance blocks further spending. It does not cancel work already commissioned or release money already held against it.