BroLabel AI Agents: How to Use Agent Wallets Safely

An AI agent needs a controlled wallet, not just an API

BroLabel AI Agents give an autonomous agent access to real onchain operations without putting a private key inside the model, prompt, or chat history. The agent can create a transaction intent, but signing still moves through a controlled Co-Signer, MPC logic, limits, and an operating ledger.

That distinction matters. If an AI agent simply receives an API key for a payment service, the team quickly runs into security questions: what exactly can it do, who sets the limits, where are secrets stored, how can a mistaken action be stopped, how is spending history audited, and who participates in signing?

BroLabel AI Agents addresses this with a production package for one agent: 30 active MPC wallets, 2 Ed25519 API keys, a customer-hosted Co-Signer, every supported production network, an immutable ledger, and WebSocket events. The base package is $99/month and includes up to $200K in confirmed monthly volume.

In practical terms: the agent can operate autonomously, but not without boundaries. You define the rules, and the infrastructure prevents "automation" from becoming uncontrolled access to funds.

When you need this

AI wallets are not needed for every chatbot. If an agent only answers questions or generates text, it does not need financial infrastructure. A wallet becomes relevant when the agent needs to buy, pay, transfer, or manage balances.

Typical use cases include:

1. paying for APIs, data feeds, inference, storage, or compute;
2. machine-to-machine payments between services;
3. stablecoin payouts inside defined budgets;
4. controlled DeFi or treasury operations;
5. reacting to events and paying without manual approval for every small action;
6. testing x402-compatible payment flows.

In each case, the hard part is not creating an address. The hard part is making sure the agent never receives a raw key, cannot bypass policy, and does not create spending that finance or operations cannot explain.

What is included in the BroLabel AI Agent package

BroLabel positions the AI Agent package as a production package for one autonomous agent. It is better to read it not as "a wallet for $99," but as a small controlled stack for agentic payments.

The package includes:

1. 30 active MPC wallets. Use them for different agent workflows, networks, assets, or operating flows.
2. 2 Ed25519 API keys. One key can be scoped for the agent; the second can be reserved for rotation or emergency recovery.
3. Customer-hosted Co-Signer. The client MPC share runs in your environment, usually as a Docker container.
4. Threshold MPC signing. In the default 2-of-2 model, neither side can sign a transaction alone.
5. Immutable ledger and WebSocket events. The team can track deposits, sends, statuses, balances, and signing outcomes.
6. All supported production networks. This does not mean every blockchain in existence. It means every network BroSettlement has released and enabled for this package at the time you use it.

Network gas, validator fees, routing costs, and third-party service fees still need to be accounted for. They do not disappear because an agent is operating autonomously.

How to start

The first step is to open the AI Agents page and copy the installation prompt. Paste it into Codex, Claude Code, Cursor, or another AI agent that supports skills.

The prompt asks the agent to install two official BroSettlement Agent Skills from GitHub:

1. brosettlement-onboarding;
2. brosettlement-api.

The full reference is available in the Agent Skills API reference, while the wallet, ledger, and settlement operations run on top of BroSettlement.

Before installation, the agent should show the destination directory, avoid overwriting existing skills, and inspect the SKILL.md files and bundled scripts. This is not a formality. Skills give the agent instructions for working with infrastructure, so they should be treated like code dependencies, not random prompts from the internet.

After installation, the agent activates $brosettlement-onboarding and guides the team through setup: BroSettlement account access, API identity, Co-Signer, MPC/DKG readiness, and the first testnet wallet.

What the transaction flow looks like

In a normal flow, the agent does not "sign crypto." It creates an intent.

The intent should include wallet, network, asset, amount, destination, and an idempotency key. The request is signed with an API key, then your Co-Signer evaluates local policy: allowed network, allowed asset, amount within limits, destination allowed or not blocked, acceptable timing, and velocity rules.

There are three possible outcomes:

1. the Co-Signer auto-approves the request;
2. the Co-Signer rejects the request;
3. the Co-Signer sends the request to a callback or manual approval path.

If policy allows the operation, the Co-Signer and BroSettlement MPC Signer jointly produce a valid signature. The full private key is never assembled. The transaction is then sent to the network, and the team tracks status through the ledger and WebSocket events.

That is the core advantage: the AI agent can move quickly, but final action still crosses a control boundary.

Rules to define for the agent

The worst way to launch an agent wallet is to tell the agent: "pay whenever you think it makes sense." That is convenient in a demo and dangerous in production.

Before production, define:

1. Budget. How much the agent can spend per day, week, and month.
2. Asset policy. Which assets are allowed, such as USDT or USDC only.
3. Network policy. Which networks the agent may use.
4. Destination allowlist. Where the agent can pay without manual review.
5. Transaction limits. Maximum amount per transaction.
6. Velocity limits. How many operations are allowed over a period of time.
7. Emergency pause. Who can stop agent payments and how.
8. Review rules. Which transactions require a human or callback service.

These rules should live outside the prompt. The model can propose an action, but runtime policy should be enforced in controlled infrastructure.

What not to do

Some boundaries should be explicit from day one.

Do not paste API private keys into chat. Do not pass encryption keys through prompts. Do not expose MPC share material in tool output. Do not store secrets in logs. Do not allow the agent to change its own limits without separate approval.

Also, do not treat an "AI Agent Wallet" as an automatic compliance solution. BroSettlement can provide wallet records, transaction metadata, role controls, signing evidence, ledger history, and events. KYC/KYB, AML decisions, Travel Rule automation, licensing, and jurisdiction analysis remain the responsibility of the operator and its integrations.

One more practical point: confirm network availability before production. Asset support, fees, and operational limits can change, so a production integration should be confirmed before real volume starts.

How to know you are production-ready

Before production, walk through a simple checklist.

First, the agent should operate through scoped API access, not a raw private key. Second, the Co-Signer should run in a controlled environment with a protected persistent volume. Third, DKG and MPC readiness should be tested on testnet. Fourth, policies should be expressed in code or a callback service, not only in model instructions.

Fifth: observability. The team should see what the agent intended to do, what policy allowed, what was signed, what was sent to the network, and what final status the transaction received. Without WebSocket events and a ledger, AI payments quickly become a black box.

Sixth: finance reconciliation. If an agent spends money, finance should see more than an on-chain hash. It needs business context: which agent, which budget, which action, which invoice or service, and what balance impact.

Practical takeaway

BroLabel AI Agents should be used not as a toy wallet for a model, but as a controlled payment runtime for autonomous systems. The agent gets the ability to act, but not unlimited authority over funds.

The best starting path is straightforward:

1. open the AI Agents page;
2. copy the installation prompt;
3. install brosettlement-onboarding and brosettlement-api;
4. create a testnet organization and first wallet;
5. define limits, allowlists, and emergency pause;
6. verify events, ledger entries, and reconciliation;
7. then move toward production operations.

AI agents need autonomy. Payment infrastructure needs a control boundary. A useful agent wallet lives exactly between those two requirements.