Programmable
Autonomous Workers
The operating system for autonomous AI agents. 21 channels, 8 AI providers, MCP protocol, multi-agent crews, and its own Solana-native programming language. Every action follows a strict 8-stage pipeline.
Everything an Agent Needs
From natural language understanding to on-chain execution, built from the ground up for autonomous operation.
MCP Protocol
Connect to any MCP-compatible server. Discover and invoke remote tools through JSON-RPC 2.0 with SSRF protection and auth.
Multi-Agent Crews
Orchestrate sequential, parallel, and hierarchical agent teams. Each crew member has its own role, goal, and tool access.
21 Channels
Telegram, Discord, Slack, WhatsApp, Email, SMS, Twitter, GitHub, REST API, WebSocket, MQTT, RSS, voice and more.
Deep Research
Multi-step web research with source validation, citation extraction, and AI-powered synthesis across multiple queries.
Extended Thinking
Claude extended thinking, OpenAI reasoning tokens, and chain-of-thought with configurable depth for complex problems.
Code Sandbox
Isolated VM execution with resource limits, timeout protection, and security validation for safe code running.
Workflow Engine
DAG-based workflow graphs with conditional routing, parallel execution, retries, and deep-cloned state isolation.
Safety Pipeline
3-layer validation (schema, logic, policy), risk scoring, transaction caps, DeFi slippage limits, and full audit trail.
Live Browser
Headless Chromium automation: navigate, click, type, extract, screenshot. The agent sees and interacts with the real web.
Plugin System
Discover, load, and manage plugins with lifecycle hooks, manifest validation, and path traversal protection.
Self-Healing
When execution fails, the healer retries with exponential backoff, then rolls back completed steps in reverse order.
Voice Control
Wake word detection, speech-to-text, text-to-speech. Talk to your agent hands-free with Whisper and Piper engines.
The 8-Stage Safety Pipeline
Every message flows through eight audited stages. Natural language in, validated actions out.
21 Channels, One Agent
Deploy your agent anywhere. Every channel uses the same safety pipeline, the same tools, the same brain.
+ Notion, Calendar, Desktop, Webchat, Voice, Browser, CLI, Cron, Webhooks — 21 total
Why PAW?
Other frameworks let LLMs run loose. PAW puts safety, auditability, and real execution control first.
Safety is Non-Negotiable
Every action passes through 3-layer validation with risk scoring. Transaction caps, forbidden action detection, DeFi slippage limits, and Solana pre-simulation are enforced before anything touches a chain or API.
Three Modes of Autonomy
Supervised confirms every action. Autonomous only stops for critical risks. Free mode lets the agent operate with full autonomy — protected by the 2-layer safety net underneath.
Full Audit Trail
Every request gets 8 traced phases logged to append-only JSONL with a trace_id + session_id. Sensitive fields (private keys, API tokens) get scrubbed before they hit disk. 90-day retention, runtime queries.
Intelligent Self-Healing
When Step 3 fails, the system retries with exponential backoff. If it still fails, compensation rollback executes in strict reverse order. Each step can declare its own undo action. Saga pattern, not brute-force retry.
Semantic Memory
Vector-based long-term memory with per-user profiling, conversation branching, and context-aware retrieval. Your agent remembers past interactions and gets smarter over time.
Extensible by Design
MCP protocol for remote tools, plugin manager with lifecycle hooks, skill files for domain knowledge, workflow DAGs for complex orchestration. Build once, compose endlessly.
Its Own Programming Language
PAW is the only AI agent framework with its own Solana-native programming language. Write once, compile to Anchor Rust + TypeScript SDK + Frontend.
program TokenSwap { account Pool { token_a: pubkey, token_b: pubkey, reserve_a: u64, reserve_b: u64, fee_bps: u16 } pub instruction swap(amount_in: u64) { // Checked math, SPL transfers let fee = amount_in.checked_mul(pool.fee_bps) let net = amount_in.checked_sub(fee) spl.transfer(user, pool_vault, net) } }
Anchor Rust, TypeScript SDK, Frontend UI, and IDL JSON from a single .purp file.
DeFi, DAO, Token-2022, math, crypto, serialization, accounts, oracle, game, NFT, governance, staking, and more.
13 lint rules, security auditing, and Solana-specific checks — overflow detection, missing signer validation, account size verification.
Fully tested upstream Purp SCL with compile, deploy, test, lint, audit, init, and template commands.
Bring Your Own Model
8 providers with automatic failover. Choose your preferred model or let PAW route to the best available. Ollama is opt-in for free local AI.
Automatic failover between all providers. PAW starts with a clean slate — you choose which AI model to inject via .env. Want to run for free? Install Ollama, pull Gemma 4, set OLLAMA_ENABLED=true, and you're running a full AI agent at $0/month. Combine with Claude Code for an even more powerful free setup.
Up and Running in Minutes
Three install paths: the framework, the desktop Hub, or free local AI. Choose one or all three.
# Clone and install $ git clone https://github.com/DosukaSOL/paw-agents.git $ cd paw-agents && npm install # Configure your AI provider $ cp .env.example .env # Edit .env — add your API key (OpenAI, Anthropic, etc.) # Build and run $ npm run build && npm start
# After installing PAW Agents: $ cd desktop $ npm install && npm start
# Install Ollama $ curl -fsSL https://ollama.com/install.sh | sh # Pull Gemma 4 (free, open model) $ ollama pull gemma4 # Enable in your .env $ echo "OLLAMA_ENABLED=true" >> .env $ echo "DEFAULT_MODEL_PROVIDER=ollama" >> .env
PAW starts with no default AI provider — you choose what to inject. Cloud providers need an API key. Ollama is 100% free and runs locally on your machine. Works with any Ollama model: Gemma 4, Llama 3, Mistral, Phi-3, CodeGemma, and more.
Real-Time Agent Control
A live web dashboard showing execution traces, channel activity, cost tracking, and the full audit trail.