Budgent

$BUDGENT is live. CA: 27N8hzrW2wt9aH124djxtbYjJXYurWsQ1e9d6h4Hpump A Solana wallet built for AI agents. Set a budget with hard rules, your agent spends within them, you see exactly where every dollar went. Scoped keys instead of full access. On-chain limits the agent can't break. Payments that carry their own context. Website: budgent.money GitHub: github.com/EthanWalkerQ/b… Program: solscan.io/account/H9nJ3S… Budget for your agent. Not keys to your wallet.  

One owner, many agents, separate vaults. Revoke one, the rest keep running.

Security – where Budgent stands Two rules that never bend: the owner can always withdraw funds, and the program stays verifiable - a deterministic build whose on-chain hash matches the published source. Live now: non-custodial withdraw, verified program, full on-chain enforcement (per-tx, daily, allow/block, co-sign, delegate kill-switch), and scoped revocable keys where the agent never holds the wallet. Not done yet: an independent external audit. It's planned, and until it's complete we say so plainly - treat the amounts flowing through a vault conservatively. The program id is public. Rebuild it yourself and check the hash. Don't trust, verify.

Every secret on Budgent sits where it should. The master key never leaves your wallet. The delegate key lives in secure storage, not in your agent's code. Your HMAC secret stays server-side and the UI never sees it. Nothing sensitive is ever floating where it shouldn't be.

Daily limits on Budgent use a rolling 24-hour window, not a midnight reset. So an agent can't blow the full cap at 11:59pm and the full cap again at 12:01am. Spending is measured against the actual last 24 hours, every time. A tighter cap that actually holds.

Funding more than one agent on Budgent? Each gets its own vault. Separate budgets, separate rules, separate delegate keys. One agent burning through its daily cap never touches another's funds. Revoke one and the rest keep running. Run a whole fleet, keep every agent boxed in on its own.

The owner on Budgent can always withdraw. No matter the policy, the delegates, or the pending queue, your master key can pull funds from the vault at any time. Nothing in the system can lock you out of your own money. Non-custodial means non-custodial.

Every payment on Budgent ends in one of three verdicts. Settled: passed policy, confirmed on-chain. Reverted: broke a rule, rejected by the program, no funds moved. Held: waiting on your approval. You always know exactly where a transaction stands - no guessing, no silent failures.

Your agent hits an unknown domain on Budgent? You decide what happens. Add domains to an allowlist and only those go through automatically. Anything new can be set to pause for your approval instead of paying blind. Your agent stays useful without spending on places you never vetted.

Big payment? Budgent can require your sign-off. Set a co-sign threshold and anything above it pauses in an approval queue instead of going through. Your agent keeps running on small stuff, you only step in when it actually matters. Control without being in the loop for every $2 API call.

On-chain enforcement: the rule isn't a suggestion. The transaction just gets rejected.

Every Budgent payment carries context, not just an amount. Domain, URL, a readable description, and the task ID travel with each transaction. The full context lives off-chain, and a hash of it is anchored in the Solana memo. So your history reads like a receipt, and you can prove it matches the chain.

Most agent wallets today are a private key in an env file. We can do better.

One agent pays another, with budget and context surviving the hop. An agent can now pay another agent for a sub-task. The payer's budget is enforced on-chain, the payee receives, and the context carries across - taskId and metadata included. So a chain of agents stays traceable, A to B to C. It's the same pay capability. The recipient just happens to be another agent. Budgets that compose, spend you can still follow.

See what your agent's money went on, not just where. New Spend by Category panel on the dashboard. Real settled spend grouped into compute, data, agents, and tools. The classifier reads the live ledger and sorts it automatically - no tagging needed. Same on-chain enforcement at the core. This is just the lens on top.

One agent hires another. That one pays a third for compute. Settles in seconds on Solana. Every hop needs a budget, context, and a kill switch.

Budgent runs two payment modes. Push: your agent pays on its own. Invoice: a service bills your agent, it pays if policy allows. Same vault, same limits, same revoke behind both.

Budgent now drops into even more agent stacks. Connecting takes minutes, not hours. New tabs for CrewAI and Vercel AI SDK, copy-paste ready. Real adapters wrapping budgent-sdk and the Python SDK - same single tool, same on-chain budget. Your agent pays, the program enforces. Seven frameworks now, one budget primitive.

Your agent goes rogue at 4am. Hitting wrong endpoints, spending too fast. You kill the delegate key in one call. Master key untouched, vault intact, agent frozen.

Your agent doesn't need your wallet. It needs a budget.