⚡ v2.7 · Sovereign Mode

The Self-Hosted AI Agent.
Engineered to Operate.

Self-hosted cognitive runtime that plans, executes, and improves itself. Real tasks with real tools, layered memory, and 41 jobs running 24/7. One-line install.

Install in one line Explore Features
37
Built-in Skills
41
Scheduler Jobs
151
Dashboard Endpoints
40+
Integrations
WASP autonomous AI agent, self-hosted cognitive runtime
browser
web_search
shell
python_exec
Dream Mode
self_improve · dry-run
layered memory
multi-agent
response_validator
A serious agent.
Built to evolve.
Sovereign Autonomy
Layered Persistent Memory
37 Built-in Skills
Dream Mode Consolidation
Multi-Agent Orchestration
Self-Hosted & Private
Self-Improvement Loop · dry-run
40+ Integrations
Multi-Provider LLM Routing
41 Scheduler Jobs
Fail-Closed Telegram · SSRF Protected
Sovereign Autonomy
Layered Persistent Memory
37 Built-in Skills
Dream Mode Consolidation
Multi-Agent Orchestration
Self-Hosted & Private
Self-Improvement Loop · dry-run
40+ Integrations
Multi-Provider LLM Routing
41 Scheduler Jobs
Fail-Closed Telegram · SSRF Protected
Why WASP

Not a Chatbot.
An Autonomous AI Agent.

Most AI tools answer questions. WASP executes tasks. Describe an objective once: the agent breaks it into steps, runs each one with real tools, monitors outcomes, and reports back. You manage nothing in between.

Capability ✦ WASP Typical Chatbot
Autonomy✓ Full goals, planning & execution✗ Response only
Memory✓ Layered persistent memory across 28 PostgreSQL tables + Redis✗ Context window only
Scheduling✓ 41 background scheduler jobs + user reminders/tasks✗ None
Self-improvement✓ Code patching, behavioral learning, recovery memory✗ None
Multi-agent✓ Full orchestration with isolated sandboxes✗ None
Infrastructure✓ Self-hosted, zero vendor lock-in✗ Cloud-dependent
Decision Layer✓ Pre-LLM heuristic router, 5 strategies, direct dispatch✗ None
Response Validation✓ Deterministic grounding/completion/drift checks + auto-recovery✗ None
Voice / Audio Input✓ Telegram voice → Whisper transcription → full pipeline✗ None
Dream Mode✓ Offline memory consolidation during idle✗ None
Plan Critic✓ LLM validation of every task graph before execution✗ None
SSRF / Network Safety✓ Centralized guard with DNS rebinding protection + redirect re-validation✗ None
Install✓ One-line cross-distro installer (10 OSes + WSL2)✗ Sign up to a service
Core Features

Everything a
Real Autonomous Agent Needs

Goal planning, real tool execution, layered persistent memory, self-improvement, and 41 background scheduler jobs on infrastructure you control.

Goal Engine & DAG Planning

Set a goal. WASP turns it into a DAG, executes each node with real tools, detects failures, and replans automatically.

GoalOrchestrator

Layered Persistent Memory

Remembers across sessions, model switches, and reboots. 28 PostgreSQL tables + Redis cache covering episodic, semantic, procedural, knowledge graph, behavioral, temporal, vector, and more.

MemoryManager

40 Real-World Skills

Browse, run code, send email, scrape, screenshot. Real tool execution, not text simulation. SSRF-protected. Custom Python skills at runtime.

SkillRegistry

Multi-Agent Orchestration

Complex tasks spawn named sub-agents with isolated memory and capability sandboxes. MetaSupervisor decomposes goals into coordinated teams.

AgentOrchestrator

Full Self-Modification

The agent reads, patches, and rebuilds its own source at runtime. Dry-run previews the diff + AST verdict before any write.

self_improve · dry_run

Dream Mode

During idle hours (1–7 am), WASP consolidates memory, enriches the knowledge graph, and reflects on recent events. Sharper when you return.

DreamJob

Multi-Provider LLM Routing

No vendor lock-in. Routes tasks across Anthropic, OpenAI, Google, xAI, and local Ollama, recovering automatically on context overflow.

ModelManager

41 Background Scheduler Jobs

Memory consolidation, perception, autonomous goals, response validation, capability evolution. Running 24/7 without supervision.

Scheduler

Behavioral Learning Loop

Correct it once. WASP detects the correction, extracts a persistent rule via LLM, and injects it into every future prompt automatically.

BehavioralLearner
System Architecture

Six Containers.
One Autonomous Brain.

Six containers, single responsibility each. One line to install:

sudo bash -c "$(curl -fsSL https://agentwasp.com/install.sh)"

agent-core

The brain. Goal orchestration, 41 jobs, dashboard (151 endpoints) on port 8080.

FastAPI · Python 3.12

agent-redis

Event bus via Redis Streams + state cache + working memory.

Redis 7

agent-postgres

Long-term memory across 28 tables: episodic, semantic, KG, behavioral, audit, timeline.

PostgreSQL 16

agent-telegram

Telegram bridge. Fail-closed: refuses to start without a user allowlist.

python-telegram-bot

agent-broker

Privileged sidecar with strict Docker-API allowlist. The only container with socket access.

Endpoint allowlist

agent-ollama

Optional local LLM runtime. No models downloaded by default; pull when needed.

Ollama · local-first
Memory System

Layered
Cognitive Memory

Across 28 PostgreSQL tables and Redis. Persists across sessions, reboots, and model switches. Full reference in docs →

01

Episodic

Full conversation history with timestamps, chat IDs, model metadata.

02

Semantic

Distilled facts and preferences extracted from conversations.

03

Procedural

Multi-step solutions abstracted as named procedures with triggers.

04

Knowledge Graph

Entity + relation extraction per message. Postgres + Redis cache.

05

Behavioral

Rules learned from user corrections. Injected into every prompt.

06

Temporal

World timeline of entity states + trend detection + change alerts.

07

Vector

Dense embeddings in Postgres JSONB. Cosine similarity, no external DB.

08

Self-Model

Live skill success rates, known failures, per-domain confidence.

09

+ 3 auxiliary

Visual, working, goal-scoped, dream log, recovery, reflection.

Skills & Tools

37 Built-in Skills
Ready to Execute

Real tool execution, not text simulation. Policy-gated across 5 tiers, audit-logged, composable. Custom Python skills at runtime.

🌐 Web & Browser
browser web_search fetch_url http_request scrape
⚙️ Code & System
python_exec shell read_file write_file self_improve skill_manager
📧 Communication
gmail slack discord send_message integration
📊 Data & Analysis
calculate summarize subscribe extract_fields translate render_report
🤖 Agent & Memory
agent_manager memory_search memory_store create_reminder task_manager
🔧 Custom Python Skills
+ any_python_class SkillBase subclass persisted across reboots auto-loaded at startup
Background Intelligence

41 Jobs Running
While You're Away

Memory consolidation, autonomous goals, perception, capability evolution. Running 24/7 with state-persistent catch-up on restart.

Dreamhourly
Autonomous Goals30min
Perception15min
Behavioral Learner2min
Goal Tick15s
Reminder Checker30s
Subscription Checker5min
Skill Evolution6h
Monitor Checker5min
Capability Evolutionhourly
CPI Monitor5min
Self Integrity6h

+ 29 more (memory pruning, vector indexing, audit retention, world model updates, etc.). See all 41 →

Self-Evolution

Autonomous
Self-Evolution

Five systems that make WASP permanently better with every interaction. No human supervision required.

Capability Evolution

When a capability is missing, WASP generates new skill code via LLM, validates it through an AST + security sandbox, and registers it live. No reboot.

sandbox-validated · max 5/day

Opportunity Engine

Scans episodic memory for repeated patterns and proactively suggests automations via Telegram. 48h dedup to avoid noise.

2/day max · pattern-driven

Self-Reflection

Post-mortem on every goal: what worked, what failed, what to do differently. Top reflections inject into future prompts.

per goal · context-injected

Response Validation

Deterministic grounding/drift/completeness check on every response. Auto-recovery on failure. Successful patterns cached for reuse.

deterministic · auto-recovery

Resource Governor

Redis-backed rate limits across goals, agents, tasks, and LLM calls. Fail-open on Redis loss. Prevents runaway autonomy.

fail-open · per-user TTL
LLM Providers

Any Model,
Zero Lock-in

Switch providers at runtime. Task-based routing picks the right model per job. Graceful recovery on context overflow.

Anthropic Claude
OpenAI GPT
Google Gemini
xAI Grok
Mistral
DeepSeek
Moonshot / Kimi
OpenRouter
Perplexity
HuggingFace
Ollama (local)
OpenAI-compatible
Security

Production-Grade
Security Hardening

Path traversal, SSRF, prompt injection, CSRF. All hardened with build-gated regression tests. 622 tests passing.

Auth & Rate Limiting

Argon2 hashing, Redis sessions (24h TTL), 5-attempt lockout, audit-logged.

CSRF Protection

Session-bound single-use tokens. X-CSRF-Token validation on every mutating request.

Path Traversal

realpath containment in self_improve. Symlink traversal blocked.

SSRF Prevention

Centralized guard with DNS rebinding protection + manual redirect re-validation. Applied to all HTTP-touching skills.

Fail-Closed Telegram

Bridge refuses to start without a user allowlist. No public-bot mode.

Gmail Allowlist

Per-address or @domain.com. Defense vs prompt-injection exfiltration.

LLM Code Injection

AST validation of all generated skill code. Blocks subprocess, eval, ctypes, pickle, importlib.

Secret Redaction

API keys auto-redacted in audit logs (OpenAI, Anthropic, Google, Stripe, Slack, HuggingFace, Bearer).

Capability Tiers

5 levels (SAFE → PRIVILEGED). Sandbox allowlists per agent. Every execution audit-logged.

Container Isolation

App containers run as UID 1000 (non-root). Docker socket only via broker allowlist proxy.

FAQ

Questions About
Autonomous AI Agents

Running a self-hosted autonomous AI agent. What you need to know.

What is an autonomous AI agent?
An autonomous AI agent receives a high-level objective, decomposes it into steps, executes them with real tools, handles failures, and delivers results without requiring human input at each step. Unlike a chatbot that only responds, an autonomous agent acts. WASP extends this with layered persistent memory, 41 background scheduler jobs, and a self-improvement loop.
How does WASP execute tasks automatically?
WASP's Goal Engine decomposes your objective into a dependency graph (DAG). Each node is executed using one of 37 built-in skills: web browser, shell, Python, Gmail, and more. The Plan Critic validates every graph before execution. If a task fails, WASP replans automatically (budget: 5 replans + storm detection). 41 background jobs keep the agent active 24/7, even when you're offline.
How is WASP different from ChatGPT or Claude?
ChatGPT and Claude are conversational models: they respond to prompts within a context window. WASP is an autonomous execution runtime: it plans multi-step goals, runs them with real tools, maintains layered persistent memory across all sessions, runs 41 background scheduler jobs continuously, and improves its own behavior over time. It is a cognitive system, not a chat interface.
How do I install WASP?
One line on any Docker-capable host: sudo bash -c "$(curl -fsSL https://agentwasp.com/install.sh)". The installer detects your distro (Debian, Ubuntu, RHEL, AlmaLinux, Rocky, Fedora, Arch, openSUSE, Alpine, macOS), installs Docker if missing, generates secure secrets, walks you through onboarding, and starts the stack. Windows via WSL2 also supported. For contributors who prefer to clone the source: curl -fsSL https://agentwasp.com/install.sh -o install.sh && sudo bash install.sh --install-method git clones from github.com/agentwasp/agentwasp.
What is a self-hosted AI agent?
A self-hosted AI agent runs entirely on infrastructure you control: your own VPS, server, or private cloud. WASP deploys with the one-line installer above. All data (memory, goals, audit logs, behavioral rules) stays on your machines. You connect your own LLM API keys. No vendor accesses your conversations or agent state.
What are the system requirements?
Minimum: 2 CPU cores, 4 GB RAM, 10 GB disk. Recommended: 4 cores, 8 GB RAM, 20 GB disk. Linux x86_64 (Debian 11+, Ubuntu 22.04+, RHEL/AlmaLinux/Rocky 9+, Fedora 38+, Arch, Alpine 3.18+, openSUSE) or macOS 13+, or Windows via WSL2. At least one LLM provider key (Anthropic / OpenAI / xAI / Google) or local Ollama.
What tools and integrations are included?
37 built-in skills: web browser (nodriver + Selenium, persistent sessions), web search, sandboxed shell, Python runtime (subprocess + RLIMIT + AST), Gmail with recipient allowlist, file I/O, SSRF-protected HTTP, crypto price monitoring, memory search/store, agent management, sub-agent orchestration, self-improve with dry-run. Plus 40+ external integrations and custom Python skills created at runtime through natural language.
What is WASP's memory system?
Layered persistent memory across 28 PostgreSQL tables and Redis. Primary layers inject into every context: episodic, semantic, procedural, visual, knowledge graph, behavioral rules, temporal world model, vector embeddings, working memory, goal-scoped, self-model, per-domain epistemic confidence. Auxiliary layers in background: learning examples, dream log, recovery memory, skill patterns, entity states, predictions, reflection. All persists across sessions, reboots, and model switches.
Does WASP work fully offline?
Yes. WASP runs on your own infrastructure via Docker Compose. PostgreSQL and Redis run locally as containers. For fully offline LLM inference, connect a local Ollama instance with any open-weight model. Your data never leaves your machine. For internet-connected tasks (web search, Gmail, etc.) you'll need network access per skill, but the agent runtime itself has no cloud dependency.
What's the license? Can I use WASP commercially?
WASP is released under the Business Source License 1.1. In plain English: you can self-host, evaluate, modify, and use it in production — including offering services to third parties — as long as your aggregate annual revenue from products incorporating WASP stays below USD $1,000,000. Above that threshold a commercial license is required. The license auto-converts to Apache 2.0 on 2029-05-13 (3 years from launch). This is a one-paragraph summary. Read the full LICENSE before commercial deployment.
● Open Source · Self-Hosted · Zero Cloud Lock-in

Run Your Own
Autonomous Intelligence

One line. One Docker-capable host. Full cognitive autonomy running in minutes.

You are not just using an AI. You are operating one.

# Install WASP v2.7 on Debian, Ubuntu, RHEL, AlmaLinux, Rocky, Fedora, Arch, openSUSE, Alpine
$sudo bash -c "$(curl -fsSL https://agentwasp.com/install.sh)"
# Install WASP v2.7 on macOS 13+ (requires Docker Desktop)
$sudo bash -c "$(curl -fsSL https://agentwasp.com/install.sh)"
# Install WASP v2.7 on Windows via WSL2 + Docker Desktop (run in PowerShell as Administrator)
PS>iwr -useb https://agentwasp.com/install.ps1 | iex

Or install from GitHub source

For contributors, forks, or pinning to a specific commit. Clones the public repo at agentwasp/agentwasp.

GitHub source
# Install WASP v2.7 by cloning the GitHub source (--install-method git)
$curl -fsSL https://agentwasp.com/install.sh -o install.sh && sudo bash install.sh --install-method git
Install Guide Read the Docs
wasp CLI
# After install, manage with the wasp CLI:
$wasp status # container health
$wasp logs # stream agent-core logs
$wasp health # run probe suite
$wasp backup # Postgres + volume snapshot
$wasp update # pull latest, rebuild, restart
# Dashboard → http://your-host:8080 ✓