Build Safe, Private &
Autonomous AI Agents
Deploy AI agents with cryptographic proofs, verifiable execution, and hardware-enforced privacy. From autonomous trading bots to personal assistants.
How to Build Safe, Private & Autonomous Agents
Check TemplatesCurate
Knowledge retrieval pattern for RAG agents. Query databases, search embeddings, and curate context before responding to user queries.
Plan-and-Execute
Break down complex tasks into steps. Agent plans the approach, executes each step, and adjusts based on intermediate results.
Multi-Agent
Coordinate multiple specialized agents. Divide tasks among expert agents and synthesize their outputs into cohesive responses.
Critique-Revise
Self-improving agents that critique their outputs and iterate. Generate, evaluate, refine until meeting quality thresholds.
Compress-ReAct
Reasoning and Acting pattern with context compression. Agent reasons, takes actions, observes results, and compresses long context.
Popular Frameworks
LangChain & LangGraph
Build stateful multi-actor applications with cycles and controllability
N8n
Low-code automation platform for complex workflows and integrations
MCP
Model Context Protocol for connecting AI models to data sources
Postgrep
PostgreSQL-based RAG system for semantic search and retrieval
Microsoft Presidio
PII detection and anonymization for privacy-preserving AI
Autonomous Agents
Self-operating agents that make decisions, execute transactions, and interact with blockchains autonomously in secure enclaves
Financial Agents
- Autonomous trading with cryptographic execution proofs
- Real-time market data analysis in secure enclaves
- Risk management with verifiable calculations
- Portfolio rebalancing with audit trails
- DeFi protocol integration with privacy
- MEV protection through private transactions
- Yield optimization across multiple chains
- Smart order routing with confidential strategies
- Compliance monitoring with private data
- API key security in hardware enclaves
AI Wallet Copilot
Intelligent wallet assistant with secure key management in TEE
- Private key protection in hardware enclave
- AI-powered transaction insights and recommendations
- Verifiable execution for all wallet operations
ERC-8004 TEE Agent
Ethereum standard for verifiable AI agents with TEE attestation
- On-chain attestation of agent execution
- Cryptographic proof of AI model integrity
- Standardized interface for verifiable agents
Coinbase X402 TEE
Secure Coinbase integration with TEE-protected API credentials
- API key security in hardware enclave
- Private trading execution with attestation
- Verifiable transaction logs for compliance
Personal Agents
Your digital assistant running in a secure enclave. Handle daily tasks with complete privacy and verifiable execution.
Vijil: Automated smart contract audit agent with verifiable security analysis
Blormmy: E-commerce agent with private shopping behavior analysis
Nous Research x Flashbot: Truth of autonomous AI agents with verifiable execution
NEAR: Financial agent with private DeFi strategies and secure execution
Rabbi: Trading agent with confidential strategies and verifiable execution
Newton: Payment agent powering verifiable AI for autonomous finance
Why Verifiable Agents Matter
Traditional AI agents run in black-box environments. Users can't verify behavior, operators can modify code, and keys/secrets are exposed to infrastructure.
Agent actions cannot be cryptographically proven
Traditional cloud infrastructure exposes sensitive information to operators and administrators.
More Information
Execution can be tampered with by operators
Hardware-enforced isolation prevents unauthorized access while maintaining computational efficiency.
More Information
Private keys exposed to cloud infrastructure
End-to-end encryption protects data in transit, at rest, and critically during computation.
More Information
No guarantee agent code matches what was published
Cryptographic verification ensures code integrity and proves execution in genuine TEE hardware.
More InformationIndustry-Leading Enterprise Compliance
Meeting the highest compliance requirements for your business
AI Agent — FAQ
Everything you need to know about building verifiable AI agents
What makes an AI Agent on Phala different from a regular agent?
A Phala-powered agent runs inside a Trusted Execution Environment (TEE) — meaning its code, data, and memory are sealed from everyone, including the cloud provider or its creator. It's the first kind of agent that is self-sovereign, tamper-proof, and verifiable by design.
Can an agent hold or use private keys safely?
Yes. Agents on Phala can generate, store, and use private keys inside an enclave. Keys never exist in plaintext outside the TEE, even to the developer. This enables autonomous DeFi agents or wallet-based bots that can sign transactions securely, similar to a hardware wallet — but fully automated.
How do I verify that an AI Agent is running the code it claims to?
Each agent instance produces a remote attestation proof, cryptographically signed by the hardware. This proof lists the enclave's code hash and identity. Anyone (users, DAOs, smart contracts) can verify it before interacting, ensuring the agent's logic matches its published version.
What prevents an operator from changing or spying on the agent?
The enclave's memory and I/O are encrypted, and the host OS or hypervisor cannot inspect or modify them. Even Phala's operators can't view the agent's internal state. Once deployed, the agent's code and model are sealed and immutable unless the developer redeploys a new signed build.
How do I deploy my own agent to Phala?
You package your agent (LLM + logic) as a container image, then deploy it to Phala Cloud using the Phala SDK or dstack runner. During launch, the node performs remote attestation and joins the Agent Network. Once verified, your agent exposes APIs or smart contract endpoints securely.
What frameworks and models can I use?
Phala supports agents built with LangChain, ElizaOS, AutoGen, or custom Python logic. Models can be any LLM (LLaMA, Mistral, Claude, GPT, etc.), provided they run inside the enclave. GPU enclaves (H200, A100) allow running both small and large model agents efficiently.
Can agents interact with blockchains or external APIs?
Yes. Phala enclaves include secure outbound call gateways that let agents query APIs or interact with smart contracts — with full attestation of each call. Agents can fetch data, trigger trades, or communicate with other services while maintaining end-to-end privacy.
What's the difference between an AI Agent and an AI dApp?
An AI Agent is an autonomous process — it runs, decides, and acts independently, often long-lived. An AI dApp is a user-facing application that may invoke agents. Phala's stack supports both: dApps as frontends and agents as backend workers that think and act privately.
Can multiple agents cooperate securely on Phala?
Yes. Agents can authenticate each other using attestation proofs and exchange encrypted messages. This makes multi-agent systems (like supply chain bots or DAO delegates) possible without a central authority.
What are "verifiable agents" and why do they matter?
Verifiable agents can prove their code and identity to others before acting. For example, an on-chain contract can verify that "Agent X is indeed running model Y in enclave Z." This transparency makes collaboration between humans, agents, and DAOs safe and auditable.
Explore Our Solutions
Discover how Phala Network enables privacy-preserving AI across different use cases
