WAIaaS: One‑Command Self‑Hosted Wallet-as-a-Service for AI Agent Wallets
WAIaaS is an open-source, self-hosted Wallet-as-a-Service for AI agent wallets — one-command Docker deployment, multi-chain support, granular policy controls
WAIaaS puts a production-ready, self-hosted wallet infrastructure on your server with a single Docker command, designed specifically for autonomous AI agents that need to hold and move real value. For teams building trading bots, DeFi strategies, or any system where agents must sign transactions, WAIaaS removes the two painful choices: hand private keys to a hosted provider or build a bespoke wallet stack from scratch. Instead, you get a browser-based admin dashboard, multi-chain wallet support, a policy engine with strict default-deny rules, session-based agent authorization, and integrated DeFi position monitoring — all running locally on your hardware and accessible at localhost:3100/admin.
Why custody and self-hosting matter for AI agent wallets
When software agents act on financial signals, custody and control are no longer academic concerns. Hosted wallet services simplify development, but they centralize key control and introduce third-party risk: platform outages, API throttling, and potential insider or platform compromises. Self-hosting returns control to the operator: private keys stay on-premises, transaction metadata remains inside your network, and you choose the operational policies and resilience posture. For enterprises and teams executing high-value strategies, this changes the risk profile dramatically — and it’s why tools that simplify on-prem wallet infrastructure are increasingly important.
What WAIaaS is and who it targets
WAIaaS is an open-source Wallet-as-a-Service implementation tailored for AI agent workflows. It targets developers, quant teams, security-conscious product teams, and any organization that needs agents to interact with EVM-compatible chains and Solana under controlled conditions. The project bundles a server daemon exposing REST APIs, a point-and-click admin UI, and a Docker-first deployment model so you can run a complete wallet stack on your hardware within minutes rather than months.
One-command deployment and the developer experience
The core selling point is operational simplicity. The stack is packaged to run in Docker and can be brought up from source with a short sequence of commands. Once deployed, a web-based admin console is available at localhost:3100 and the UI exposes the /admin interface for all operational tasks. The runtime exposes programmatic hooks as well — nearly four dozen REST endpoints are available for automation, CI pipelines, or agent integrations — meaning developers can both manage wallets interactively and integrate wallet operations into software systems.
How wallet creation and multi-chain support work
WAIaaS supports wallet creation across multiple networks spanning both EVM-style chains and Solana. The admin UI lets operators provision wallets and view addresses, balances, and transaction histories. Each wallet is a first-class entity that can be bound to permissions, policies, and sessions for AI agents. For automation, wallets can be created via the REST API by POSTing the required metadata along with a master password header; the same endpoints return wallet identifiers and can be queried to inspect balances or transactions.
Session tokens and agent authorization mechanics
Rather than embedding private keys directly into agent code, WAIaaS issues JWT-based session tokens to agents. Sessions encapsulate what an agent may do: which wallet it can access, time-to-live, renewal behavior, and absolute expiration. Operators can observe active sessions in the admin UI — when they were created, their expiry, and the permissions each session carries. Sessions are revocable in real time, providing an important response mechanism in case an agent behaves unexpectedly or an operational incident requires immediate credential invalidation.
Policy-driven controls: 21 policy types across four security tiers
At the center of WAIaaS’s security model is a rich policy engine. Policies are applied at the wallet level and span 21 distinct types that cover common attack surfaces and operational controls: token whitelists, smart contract whitelists, recipient whitelists, rate limits, time-of-day restrictions, and specialized rules for DeFi operations such as lending caps and leverage limits. Policies operate under a default-deny posture — if no matching policy allows an action, the transaction is blocked. That encourages explicit, auditable rules about what your agents may and may not do.
The engine supports four escalating enforcement tiers:
- INSTANT: small, low-risk transactions that are allowed immediately.
- NOTIFY: mid-sized transactions that go through but generate notifications.
- DELAY: larger operations subject to a configurable hold period (for example, 15 minutes) during which an operator can cancel.
- APPROVAL: high-risk transactions that require an explicit human sign-off before execution.
This tiered model lets teams balance automation speed against financial risk and oversight needs.
Practical examples: spending limits, token and contract whitelists
A typical rule set looks like a spending limit policy combined with whitelists. Small transfers can proceed without human interaction; medium transfers trigger alerts; significant moves are delayed; and very large transfers are blocked until an explicit approval occurs. Token and contract whitelists reduce exposure to phishing or rug-pull tokens by only permitting transfers involving known tokens and smart contracts, while recipient whitelists restrict outgoing flows to approved counterparty addresses.
DeFi positions and cross‑protocol visibility
For AI agents participating in DeFi, visibility into positions across protocols is essential. WAIaaS aggregates position data from a set of integrated DeFi protocols — covering lending, staking, perpetuals, and prediction markets — into a unified positions dashboard. That aggregation surfaces total exposure, health factors, P&L, and rewards so agents and operators don’t have to poll multiple services. The same dataset is available to agents via API calls, enabling programmatic strategy signals that incorporate portfolio-wide metrics rather than siloed protocol views.
Notification channels and approval UX
When policies require operator attention, WAIaaS pushes contextual notifications through configurable channels. Supported delivery includes mobile push notifications, Telegram, and WalletConnect-compatible flows, allowing operators to inspect transaction details and approve or reject requests from a phone or secure client. The notification system is configurable to prevent alert fatigue: you control which event classes generate notifications — large transfers, policy violations, failed transactions, and so on.
Docker-first production considerations
The project ships in Docker with sensible production features: named volumes for persistent storage across restarts, non-root container users for improved isolation, built-in health checks with automatic restarts, and built-in secret management options. In a production deployment you are encouraged to place master credentials into a secrets overlay and use the provided compose configurations to run the stack under an orchestration layer that implements your operational security controls. The daemon is capable of operating with Docker secrets and can auto-provision a secure master password during initial setup if you prefer that route.
Developer integration: REST APIs and automation workflows
WAIaaS presents nearly 40 REST endpoints to support programmatic operations: wallet lifecycle management, session issuance, balance and positions queries, policy management, and transaction submission. That makes it straightforward to integrate wallet control into CI/CD pipelines, trading backtests, or autonomous agent runtimes. Typical development workflows couple a CI system to call the API to provision ephemeral wallets or sessions for sandboxed tests and then tear them down. The API-first model also enables building custom operator tooling or integrations with monitoring systems and ticketing platforms for approval workflows.
Security trade-offs and hardening recommendations
Self-hosting eliminates some third-party risks but shifts responsibility for secure operation to your team. Key hardening steps include:
- Running the stack behind a hardened firewall and reverse proxy with TLS termination.
- Storing the master password in a secrets manager, not in plaintext.
- Restricting access to the admin UI via network policies and identity-aware proxies.
- Enforcing robust session lifecycle policies and short JWT TTLs for agent credentials.
- Incorporating regular backup and disaster recovery procedures for persistent volumes.
Operators should also perform periodic policy audits and test session revocation workflows to ensure that emergency responses work as intended.
Who should adopt a self-hosted wallet service like WAIaaS
WAIaaS is most relevant for teams that meet one or more of the following criteria:
- Agents will sign or move material balances and custody control is a business priority.
- You need deterministic policies and human-in-the-loop approvals for high-risk operations.
- Your workflows span multiple chains and DeFi protocols and you want consolidated visibility.
- You prefer to own operational tooling instead of relying on a hosted custody provider.
Projects that are purely experimental or low-risk may still prefer hosted wallets for convenience, but teams preparing to scale or operate under compliance constraints will find the self-hosted model provides stronger guarantees around control and auditability.
Operational patterns and business use cases
Common use cases include algorithmic trading bots that execute cross-chain strategies, treasury management automation for startups that need guarded spend controls, DeFi market-making agents that must monitor health factors and collateral, and research environments that require reproducible transaction histories for audits. The policy editor and session controls let organizations implement role-based automation: low-privilege agents handle routine tasks while high-privilege operations route through approval queues.
Integration with broader tooling and ecosystems
WAIaaS is not a closed ecosystem; it complements identity providers, observability stacks, and automation platforms. You can integrate session lifecycle events with CI/CD systems, feed policy violation alerts into incident management tools, or connect the positions API to monitoring dashboards. In contexts where AI-driven decisions intersect with compliance — for example, AML checks or enterprise CRM-driven payments — WAIaaS can become the transaction execution layer in a larger automated pipeline.
Developer implications: testing, simulation, and continuous deployment
For safe development, teams should run isolated environments that mirror production policies and use ephemeral wallets for test runs. The REST API enables fully automated provisioning of test wallets and sessions, meaning continuous integration systems can generate wallets, run scenarios, and then eject credentials without human intervention. This pattern reduces the risk of exposing production secrets during development while preserving the ability to exercise the exact authorization logic that will run in production.
Auditability, observability, and compliance considerations
The dashboard and APIs expose transaction histories, active sessions, and policy evaluations — all of which support audit workflows and post-incident analysis. Organizations with regulatory requirements should instrument logging and export relevant events to centralized SIEMs, preserving immutable records of approvals, denials, and session activity. The default-deny policy posture also provides a defensible control for auditors: absent explicit policy coverage, no transaction flows occur.
Getting started: a pragmatic checklist to run your first self-hosted wallet service
Operators can follow a straightforward playbook to provision a working environment:
- Clone the repository and start the stack with the provided Docker compose configuration.
- Visit the admin UI at http://localhost:3100/admin to finish the bootstrap and set a master password.
- Use the wallet creation form to provision a wallet on your chosen chain (EVM or Solana).
- Configure policies for spending limits, token whitelists, and rate limits before enabling agent access.
- Issue session tokens to agents and test revocation flows and approval notifications.
- Connect your monitoring and secrets systems for production readiness.
These steps let a team move from zero to a policy-governed wallet service in short order while keeping key material under their control.
Broader implications for the software and blockchain industries
Self-hosted wallet infrastructure aimed at agents marks a shift in how teams build autonomous financial software. As AI systems gain more autonomy and as programmable finance deepens, the need for deterministic, auditable controls increases. Tools like WAIaaS create an intermediate layer that allows automation to execute while preserving human oversight and corporate governance. For the developer ecosystem, that means more integration points — policy-as-code, session orchestration APIs, and cross-protocol position aggregation — that will likely spawn dedicated libraries, monitoring integrations, and third-party extensions. For businesses, owning custody and policy enforcement may become a competitive advantage where regulatory compliance and operational resilience are differentiators.
Risks, limitations, and when to avoid self-hosting
Self-hosting demands operational maturity. Smaller teams without infrastructure or security expertise might find the maintenance and hardening costs outweigh the benefits. Additionally, self-hosted systems place the onus of backups, availability, and incident response squarely on the operator. Where organizations prefer to offload operational overhead or require insured custody, a hosted or custodial provider remains an appropriate choice.
Where WAIaaS fits among other tooling
WAIaaS occupies the niche between simple wallet libraries and enterprise brokered custody. It bundles the primitives projects normally assemble — key management, signing, policy enforcement, and integrations — into a single product tailored for agents. That makes it a candidate for internal platforms teams who need a reusable, auditable service rather than bespoke implementations per team.
Operational checklist for production rollouts
Before moving to production, teams should:
- Run security scans and threat modeling exercises specific to the deployment context.
- Integrate master secrets with a vetted secret management solution.
- Configure TLS and network access policies to limit the admin UI to approved operator IPs or identity systems.
- Test disaster recovery — restore volumes and validate session and policy state recovery.
- Define incident response playbooks for key compromise, including immediate session revocation and transaction hold procedures.
These preparations reduce the risk of operational surprises and make governance at scale manageable.
Final look ahead
The convergence of autonomous AI agents and programmable finance is accelerating demand for wallet infrastructure that balances automation with human oversight. Self-hosted Wallet-as-a-Service solutions like WAIaaS aim to close the gap by delivering a deployable, policy-driven runtime that keeps keys on your machines and policy enforcement in your control. As teams adopt these patterns, we should expect richer policy languages, deeper integrations with enterprise identity and compliance tools, and more sophisticated tooling for safely testing agent behavior in production-like environments. The next wave of developer tools will likely focus on composing policy modules, standardizing session orchestration, and improving observability so organizations can scale automated financial operations with confidence.
