Private agents (testnet)

Let your AI agent swap, earn and move funds privately with Bermuda on Base Sepolia. Add private to an action and it runs from a shielded balance.

Live on testnet. Private agents run on Base Sepolia (chain 84532) with test USDC, through Thirdfy MCP, the Agent CLI and the API. Mainnet follows Bermuda's mainnet pool.

An agent that trades in public shows everyone its balance, where its money came from and what it does next. Private agents keep that money in a shielded pool instead. Thirdfy runs on Bermuda, a compliant shielded pool, so your agent can hold, swap, earn and move funds without linking each step to its public wallet.

Private actions go through the same checks as every other Thirdfy action: your agent's allowlist, its limits and Thirdfy's safety checks.

Try it in plain words

Start from zero in Claude, ChatGPT, Cursor or any app connected to Thirdfy MCP. Each step is one message. Your agent needs Trade access for the steps that move funds, and it shows you each one before it runs.

1. Check that it's ready.

Using Thirdfy on Base Sepolia, check that private agents are ready for my agent.
Show my agent's wallet address and my shielded balance.

Your agent reports whether the private pool is ready, its wallet address on Base Sepolia, and a shielded balance of 0 to start.

2. Get test USDC. Open the Circle faucet, pick Base Sepolia, and send test USDC to the wallet address from step 1.

3. Shield it.

Using Thirdfy on Base Sepolia, shield 2 USDC from my agent wallet.

This moves 2 USDC from the agent's public wallet into its shielded balance. Thirdfy pays the gas.

4. Swap privately.

Using Thirdfy on Base Sepolia, privately swap 1 USDC to WETH from my shielded balance.

The swap runs from a fresh one-time wallet, and the WETH lands back in the shielded balance. It takes about 30 seconds.

5. Earn, check and withdraw.

Using Thirdfy on Base Sepolia, put 1 USDC from my shielded balance into the private vault.

Using Thirdfy on Base Sepolia, show my shielded balance.

Using Thirdfy on Base Sepolia, move my shielded USDC back to my agent wallet.

On testnet each private move is capped at 5 USD.

Make an action private

Add private: true to a supported action. Thirdfy runs it from the agent's shielded balance instead of its public wallet. If the action can't run privately, Thirdfy refuses it. It never falls back to running in public.

Action	With `private: true`
`swap`	Swaps from the shielded balance on a fresh one-time wallet and shields the result again
`deposit_earn_position`	Enters a vault from the shielded USDC balance and keeps the vault shares shielded
`withdraw_earn_position`	Exits the vault back into the shielded USDC balance. Without an amount, it exits everything

private: true works when your agent is allowed to run that action. The Bermuda actions below work for every agent, so a private swap can always run as bermuda_stealth_swap.

These calls need a shielded balance first (step 3 above). Call them yourself:

MCP

CLI

walletExecute { action: "bermuda_stealth_swap", chainId: 84532, estimatedAmountUsd: 1,
  params: { chainId: 84532, tokenIn: "USDC", tokenOut: "WETH", amount: "1" } }

The same swap through swap, for an agent allowed to run it:

thirdfy-agent run --action swap --chain-id 84532 --run-mode agent_wallet \
  --params '{"tokenIn":"USDC","tokenOut":"WETH","amountInHuman":"1","tokenInDecimals":6,"chainId":84532,"private":true}' \
  --estimated-amount-usd 1 --confirm-writes --json

For a private vault deposit, pass the vault too:

thirdfy-agent run --action deposit_earn_position --chain-id 84532 --run-mode agent_wallet \
  --params '{"chainId":84532,"vaultAddress":"0x99067e5D73b1d6F1b5856E59209e12F5a0f86DED","amount":"1","private":true}' \
  --estimated-amount-usd 1 --confirm-writes --json

On Base Sepolia, private swaps trade USDC and WETH, and private earn uses the MetaMorpho USDC vault above. Any other vault is refused.

Everything a private agent can do

You can also call the Bermuda actions directly:

Action	What it does
`get_bermuda_setup_status`	Checks that the pool, relayer and compliance service are ready. Read only
`get_bermuda_balance`	Shows the shielded balance (USDC, WETH and vault shares)
`bermuda_deposit`	Moves USDC from the agent's public wallet into its shielded balance
`bermuda_transfer`	Moves shielded USDC between the agent's own private accounts
`bermuda_withdraw`	Moves shielded USDC out to a public address (the agent's own wallet by default)
`bermuda_stealth_swap`	Private swap. The same as `swap` with `private: true`
`bermuda_stealth_earn`	Private vault entry. The same as `deposit_earn_position` with `private: true`
`bermuda_stealth_exit`	Private vault exit, back to shielded USDC (`amount`, or `all: true`)
`bermuda_sweep_burners`	Returns small leftovers from past private swaps to the shielded balance

Only bermuda_deposit touches the agent's public wallet. Every other write is relayed by Bermuda, so the public wallet never appears and needs no ETH for gas.

Try it with the CLI

1. Give this to your agent:

Read https://docs.thirdfy.com/agents.md. Then, on Base Sepolia (chain 84532) only,
check that Thirdfy private agents are ready with get_bermuda_setup_status and show
me my shielded balance. Ask me before you move any funds.

2. Get test USDC. Send Base Sepolia USDC (0x036CbD53842c5426634e7929541eC2318f3dCF7e) from the Circle faucet to your agent's execution wallet. Thirdfy pays the gas for the deposit.

3. Shield it, then act privately. With the Agent CLI:

# Check that private writes are ready (look for writeReady: true)
thirdfy-agent run --action get_bermuda_setup_status --provider bermuda \
  --params '{"chainId":84532}' --json

# Move 1 test USDC into the shielded balance
thirdfy-agent run --action bermuda_deposit --provider bermuda \
  --params '{"chainId":84532,"amountUsdc":1}' \
  --run-mode agent_wallet --confirm-writes --json

# See the shielded balance
thirdfy-agent run --action get_bermuda_balance --provider bermuda \
  --params '{"chainId":84532}' --json

Then run the private swap or deposit from Make an action private. To check a write first without sending anything, run the same command with thirdfy-agent preview instead of run. Over MCP, use the same actions with walletExecute, or ask in plain words from Claude, ChatGPT or Cursor.

Keep it private

Each private write returns privacyNotes with tips like these:

Use round amounts. A distinctive amount (like 1.2374 USDC) can be matched to the same amount on the public side.
Leave time between steps. A deposit followed right away by a swap of the same size is easier to link.
Withdraw to a fresh address. Where a withdrawal lands is public.
Sweep leftovers. Run bermuda_sweep_burners now and then to bring swap leftovers back into the shielded balance.

What stays public

Shielding hides the money between moves. It does not hide everything.

The trade itself is visible. A swap or vault deposit shows on chain, from a one-time wallet that is not linked to your agent. Each private swap uses a new one.
Deposits into and withdrawals out of the pool are visible.
Every deposit is screened. Bermuda runs compliance checks before funds enter the pool. Bermuda is a compliant shielded pool, not a mixer.
Your agent's rules still apply. Allowlists, limits and Thirdfy's checks run on every private action.

Limits on testnet

Each private write is capped at 5 USD. Sweeping leftovers has no cap.
Private swaps allow up to 3% slippage (0.5% by default). Batches and all / max amounts are refused on private swaps.
A private write takes about 30 seconds, because the pool builds a zero-knowledge proof and Bermuda relays it.
Private actions use credits like any other write. There is no extra privacy fee at launch.

If something goes wrong

You see	What it means
`writeReady: false` with `BERMUDA_COMPLIANCE_UNAVAILABLE`	Bermuda's compliance service is not answering. Reads work; try writes again later
`PRIVATE_NOT_SUPPORTED`	This action has no private version. Use one from the tables above
`Action "swap" is not … allowed for this agent`	Your agent's allowlist doesn't include `swap`. Use `bermuda_stealth_swap`, or allow `swap` for the agent
`AMOUNT_UNIT_DECIMALS_REQUIRED`	With `amountInHuman` on `swap`, also pass `tokenInDecimals` (6 for USDC)
`BERMUDA_INSUFFICIENT_UTXO`	The shielded balance is too small. Shield more with `bermuda_deposit`
`sizingWarnings: PRIVATE_BALANCE_NOT_CHECKED`	Not an error. Thirdfy can't read the shielded balance before running, so the pool checks it instead
`CHAIN_NOT_SUPPORTED`	Use `chainId: 84532`
`BERMUDA_ACTIONS_DISABLED`	Private agents are not switched on for that API host

What comes next

Mainnet once Bermuda's mainnet pool is live.
Private agent payments: paying for services and credits from shielded funds.
Private templates on EarnOrg: yield and trading agents with a shielded funding leg.

Supported chains

Every chain where Thirdfy agents can act today, EVM and Solana, with chain IDs, run modes and venue links.

Agent learning data

How Thirdfy records governed execute stage events for ops analytics. Training and TFY rewards are not live.

On This Page

Try it in plain words
Make an action private
Everything a private agent can do
Try it with the CLI
Keep it private
What stays public
Limits on testnet
If something goes wrong
What comes next
Related

Buy credits Discover Agents Deploy on EarnOrg Agent network Vision TFY V2 tokenomics Join Discord Follow on X