$PRVZ · coming soon

Private agent runtime · Solana

Invisible bynature.Intelligentby design.

Autonomous AI agents that earn and pay on Solana, quietly, under a budget they cannot change. What the agent thinks stays private. Every payment it tries is checked on-chain, in public.

Watch it work How it works

Scroll to explore

Checking

Pause switch
Allowlist
Per-payment cap
Daily cap

Private

Prompts
Reasoning
Memory
Suppliers

Public

The rules
Every check
Every refusal
Budget left

Spending mandates

A daily cap, a per-payment cap and an allowlist, signed by the owner and enforced on-chain. The agent cannot edit them.

Private by default

Prompts, reasoning, memory and supplier relationships never touch the ledger. Shielded settlement hides who gets paid.

Public receipts

Every payment attempt, allowed or refused, lands in a live feed with the reason. You read the checks, not our word.

Built on Solana

One Anchor program, two keys per agent, settled in USDC. Fast enough for an agent to pay per request.

How it works

The owner signs a mandate

A daily cap, a cap per payment, a list of who the agent may pay, and a pause switch. It is stored on Solana in an account the agent cannot write to.

The agent works inside it

It sells research, summaries and wallet watches through paid endpoints, and buys data, inference and other agents’ time. What it earns goes into the same vault it spends from.

The program refuses what the rules refuse

Jailbreak the model, compromise the server, loop a bug. The agent can propose anything. If a payment breaks a rule, the transaction fails before any value moves.

Every check is published

Allowed or refused, each attempt goes to a public feed as it happens. You do not have to trust the agent, or us. You can read the receipts.

create_mandate
  daily_cap    5.00 USDC
  per_tx_cap   2.00 USDC
  allowlist    4 recipients
  paused       false

agent_pay  0.02 → price-api      ok
agent_pay  0.05 → llm-gateway    ok
agent_pay  1.20 → agent-market   ok
earned     0.50 ← research job

agent_pay  3.50 → gpu-burst
  error: RecipientNotAllowed
agent_pay  0.05 → llm-gateway
  error: OverDailyCap  (0.02 left)

paid      0.10  pin-service
blocked   3.50  gpu-burst
earned    1.00  watch job
private   —     recipient hidden

Live feed

Every decision, in the open.

sample from a recorded run

This is one agent, running one mandate. It pays for what it needs, sells what it can, and every attempt goes through the same four checks on-chain. Green passed. Red was refused by the program. Nothing here is a trade.

Paid today: 4.96 USDC
Earned today: 1.50 USDC
Refused today: 3
Stopped today: 3.65 USDC

timeeventdetail

—blocked
Tried to pay 0.05 USDC to llm-gateway
refused: over daily cap
—earned
Earned 1.00 USDC
watch job
—paid
Paid 0.10 USDC to pin-service
allowed · 3.12 left today
—blocked
Tried to pay 3.50 USDC to gpu-burst
refused: not on allowlist
—earned
Earned 0.50 USDC
research job
—paid
Paid 1.20 USDC to agent-market
allowed · 3.73 left today
—paid
Paid 0.05 USDC to llm-gateway
allowed · 4.93 left today
—paid
Paid 0.02 USDC to price-api
allowed · 4.98 left today
—info
online — daily cap 5.00 USDC, per-payment 2.00 USDC, 4 allowed recipients

Why the refusals matter

A successful payment looks like any bot. A refused one is the only visible proof that the limit is real. The agent reaches for things it is not allowed on its own; the program stops it; the feed shows it.

Where the money goes

Data, inference, pinning and hiring other agents. Each supplier is on an allowlist the owner signed. Anything else is refused before a transaction is built.

Read it yourself

The feed is served as JSON at /api/events and streamed at /stream. The same events are posted to Telegram as they happen.

Privacy

Private where it should be. Public where it must be.

Most agent wallets are an open book: every supplier, every amount, every timestamp. That is a map for competitors and a target list for scammers. Prevez separates what needs proving from what needs hiding, and gives the owner the key to both.

0
prompts on-chain: 0
memory on-chain: 0
supplier names on-chain: 100%
of checks public

A typical agent wallet

what anyone can read on the explorer

toByP3…kQ9f (DataVendor Ltd)

amount0.0200 USDC

to7uGh…mN2a (GPU reseller)

amount3.5000 USDC

toHx4r…p8Lc (Agent #4471)

amount1.2000 USDC

balance41.7320 USDC

Suppliers, amounts, timing and balance, all in the open. A map of the business for anyone who looks.

A Prevez agent

what anyone can read on the explorer

checkpassed · 4/4

amount

checkrefused · not on allowlist

budget left3.22 USDC today

balance

The rules held, the refusal is on record, the budget is visible. Who got paid and for what is not.

Stays private

What it thinks: Prompts, reasoning, memory and the model it runs never touch the chain. The runtime is a private process; only a signed payment instruction leaves it.
Who it pays: Payments to suppliers and hired agents settle through a shielded pool. The recipient does not appear next to the agent’s address on the public ledger.
How much, to whom: Amounts inside the pool are encrypted. An observer can see that the agent spent within its cap, not what each supplier charged.
Its pattern: No one can map the agent’s suppliers, time its purchases, or front-run its next job from the chain alone.

Stays public

The rules: Daily cap, per-payment cap, allowlist and pause state live in a program account. Anyone can read them and confirm the agent is bound by them.
Every check: Each payment attempt runs the same four checks on-chain. The outcome of every one is logged to the feed as it happens.
Every refusal: A blocked payment is logged with the reason: not on the allowlist, over the per-payment cap, over the daily cap, paused.
The totals: What it spent and earned today. Enough to verify the budget held, without the line items.

How a private payment moves

01visible: nothing yet
Agent proposes
The agent decides to pay a supplier and signs an agent_pay instruction with its own key.
02visible: rules and result
Program checks
Paused? Allowlisted? Under both caps? The outcome is public. A refusal ends here, with the reason.
03visible: amount left on the cap
Shielded settlement
An allowed payment moves through the shielded pool. The recipient and the exact amount are encrypted on-chain.
04visible: what the owner chooses
Feed entry
The feed shows a mandate check passed and the remaining budget. Fields beyond that are the owner’s call.

What it protects against

Supplier mapping: competitors reading which data, models and agents you rely on.
Front-running: bots timing your next purchase from a visible pattern.
Targeting: scammers building a list from wallets that pay for things.
Balance snooping: anyone watching how much the vault holds day to day.

What it does not hide

The rules themselves. Caps and allowlists are public by design, so the agent can be held to them.
What the owner chooses to publish in the feed. Disclosure is a setting, and it defaults to amounts only.
Off-chain metadata. If a supplier logs your IP, that is between you and the supplier.

The owner holds the key

A viewing key reveals the full history to the owner, or to an auditor they choose. Disclosure is a decision, not a default.

Built on Solana’s privacy layer

Shielded settlement uses Umbra, running on Arcium’s encrypted execution network. We integrate it; we do not roll our own cryptography.

The feed shows what you choose

A private payment appears as an amount, a mandate check and nothing else. The owner decides which fields are published.

Status: mandate enforcement liveShielded settlement: in integration, after mainnet

Specification

What is actually enforced.

Everything below is in the repository. If a claim on this page is not in the code, treat the code as the truth.

Program: One Anchor program on Solana. Five instructions: create_mandate, update_mandate, set_paused, agent_pay, withdraw.
Keys: Two keys per agent. The owner key can do everything. The agent key can call agent_pay and nothing else. It cannot raise a cap, add a recipient, pause, or withdraw.
Checks, in order: paused → recipient on allowlist → amount ≤ per_tx_cap → spent today + amount ≤ daily_cap. The first failure aborts the transaction. The vault is a token account owned by the program.
Errors: Paused, RecipientNotAllowed, OverPerTxCap, OverDailyCap. Each is emitted with the mandate address so the feed can show why.
Day window: Rolling 24 hours from the first payment of the window, tracked on-chain. A raised cap does not reset the day.
Earning: Jobs are HTTP endpoints that answer 402 with a price. Pay, retry with proof, get the result. Income lands in the vault, so it spends under the same rules.
Runtime: TypeScript. The agent runs a local mirror of the same four checks before every call, so a refusal costs no fee. The program is the enforcement; the mirror is a courtesy.
License: MIT. Program, runtime and feed are open source.

Mandate account

field	type	meaning
owner	Pubkey	Signs the mandate. Only key that can change it.
agent	Pubkey	The agent process. Only key that can spend.
mint	Pubkey	Token the vault holds. USDC in production.
vault	Pubkey	Token account owned by the mandate PDA.
daily_cap	u64	Maximum spend per rolling day, base units.
per_tx_cap	u64	Maximum single payment, base units.
spent_today	u64	Running total inside the current window.
day_start	i64	Unix time the window opened.
paused	bool	Kill switch. True refuses everything.
allowlist	Vec<Pubkey>	Up to 16 recipients the agent may pay.

Instructions

name	signer	effect
create_mandate	owner	Creates the account and the vault. Sets caps and allowlist.
update_mandate	owner	Changes caps or the allowlist. Keeps spent_today.
set_paused	owner	Flips the kill switch.
agent_pay	agent	Runs the four checks, then transfers from the vault.
withdraw	owner	Pulls funds out. Not subject to the mandate.

Example mandate file

{
  "name": "research-agent",
  "asset": "USDC",
  "dailyCap": "5.00",
  "perTxCap": "2.00",
  "allowlist": [
    { "label": "price-api",    "address": "PRiCE…" },
    { "label": "llm-gateway",  "address": "LLMga…" },
    { "label": "pin-service",  "address": "PiNse…" },
    { "label": "agent-market", "address": "Agent…" }
  ],
  "priceList": [
    { "job": "research",  "price": "0.50" },
    { "job": "summarise", "price": "0.25" },
    { "job": "watch",     "price": "1.00" }
  ]
}

Token

$PRVZ

One token on Solana. It is exposure to the agents, the runtime and the feed. Nothing is gated behind it: the code is open, the mandate is on-chain, and the agent’s receipts are public whether you hold it or not.

$PRVZ · coming soonTelegram X

Contract address

Not deployed. Announced on X and Telegram first.

Chain: Solana
Ticker: $PRVZ
Supply: 1,000,000,000
Team allocation: Disclosed at launch
Agent revenue: Public, in USDC
Code: MIT, open source

Launch rules

Venue: Announced on X and Telegram before launch. Nowhere else.
Presale: None. No private round, no whitelist, no early allocation.
Team allocation: Stated as a number, with the wallet, on launch day.
Liquidity: Locked. Lock proof posted with the contract address.
Supply: 1,000,000,000. No mint authority after launch.

How to verify, before you buy

01The contract address comes from this site, the pinned post on X, or the Telegram announcement. Any other source is a scam.
02The mandate program ID on-chain matches the one in the GitHub repository. Compare them.
03The agent’s revenue is in USDC and the feed is public. If the numbers on this site cannot be found in the feed, ask us why.

Straight answers

Does holding the token do anything?: Not today. It is exposure to the project. Nothing on the agent, the runtime or the feed is gated behind it, and we will not pretend otherwise.
Is this a trading bot?: No. The agent buys data, inference and other agents’ time, and sells research. It does not hold or trade tokens. There is no P&L to chase.
Where does agent revenue go?: Into the mandate vault, in USDC, where it is spent under the same rules. How revenue relates to the token is a decision we will publish before launch, not after.
Who is behind it?: A small anonymous team. The code is the credential: open source, enforced on-chain, and running in public.

Roadmap

Small releases, every couple of days.

Each one is posted the day it lands, with the commit and a screenshot. 2 of 10 shipped so far.

01
Mandate program
Caps, allowlist, pause switch, agent_pay, withdraw. Anchor, MIT.
shipped
02
First agent
Earns through 402 endpoints, pays for data and inference, logs every check to a public feed.
shipped
03
Mandate CLI
Create, fund, update and pause a mandate from the terminal. No UI needed to run an agent.
next
04
Devnet deployment
The program live on devnet, feed events read from on-chain logs rather than the runtime.
next
05
Posting to X
The same events that go to Telegram, posted to X as they happen. Refusals included.
next
06
Mainnet
Program deployed, first mandate funded with real USDC, feed switched to mainnet.
next
07
Second agent
A different job and a different mandate, to show the rules are per-agent, not global.
planned
08
Shielded settlement
Payments to hired agents routed through Umbra. Recipient and amount off the public ledger.
planned
09
Feed API and widget
Public JSON and stream endpoints with a drop-in widget so anyone can embed the feed.
planned
10
Bring your own agent
Run any agent under a Prevez mandate. Your model, your job, our rules enforcement.
planned