⚡ v2.2 · Sovereign Mode

Autonomous Intelligence,
Engineered to Operate.

WASP is a self-hosted cognitive runtime that plans, executes, and improves itself, running real tasks with real tools, powered by an 18-layer memory system, 37 skills, and 27 autonomous background processes. No dependencies. Built for control. Designed to operate.

Get Started Explore Features
37
Built-in Skills
18
Memory Layers
27
Background Jobs
40+
Integrations
WASP autonomous AI agent, self-hosted cognitive runtime
browser
web_search
shell
python_exec
Dream Mode
self_improve
18-layer memory
multi-agent
response_validator
🧪 Development Status

Agent Wasp is under active development. New capabilities and improvements are continuously being released to enhance performance and intelligence.

Sovereign Autonomy
18-Layer Memory
37 Built-in Skills
Dream Mode Consolidation
Multi-Agent Orchestration
Self-Hosted & Private
Self-Improvement Loop
40+ Integrations
Multi-Provider LLM Routing
27 Background Jobs
Production Security Audit
Sovereign Autonomy
18-Layer Memory
37 Built-in Skills
Dream Mode Consolidation
Multi-Agent Orchestration
Self-Hosted & Private
Self-Improvement Loop
40+ Integrations
Multi-Provider LLM Routing
27 Background Jobs
Production Security Audit
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 goal decomposition, DAG planning & execution✗ Single-response only
Built-in Skills✓ 37 skills: browser, shell, Python, Gmail, Slack, search, and more✗ Text generation only
Memory✓ 18-layer system — episodic, semantic, procedural, visual, temporal✗ Context window only
Scheduling✓ 27 background jobs, user-defined recurring tasks✗ None
Self-improvement✓ Runtime code patching, behavioral learning, capability evolution✗ None
Multi-agent✓ Full orchestration with capability sandboxes and message bus✗ None
LLM Providers✓ 12 providers — switch at runtime, task-based routing, overflow recovery✗ Single provider, hard-coded
Infrastructure✓ Self-hosted on your VPS, zero vendor lock-in, Docker Compose✗ Cloud-dependent
Decision Layer✓ Pre-LLM heuristic router, 5 strategies, 13 fast-path patterns✗ None
Response Validation✓ 9 deterministic checks — grounding, completeness, drift + auto-recovery✗ None
Plan Critic✓ LLM validates every task graph before execution begins✗ None
Voice Input✓ Voice messages → OpenAI Whisper transcription → full pipeline✗ None
Dream Mode✓ Offline memory consolidation, KG extraction, reflection during idle✗ None
Security✓ SSRF guards, CSRF, path traversal protection, 21-finding audit✗ Not applicable
Core Features

Everything a
Real Autonomous Agent Needs

Your agent does the heavy lifting. Goal planning, real tool execution, 18 layers of persistent memory, self-improvement, and 27 continuous background jobs, all running on infrastructure you control, with zero cloud dependencies.

Goal Engine & DAG Planning

Set a goal. Get results, without supervising each step. WASP generates a dependency graph (DAG), executes each node with real tools, detects failures, replans automatically, and reports completion with full output.

GoalOrchestrator

18-Layer Memory System

Remembers everything that matters, across sessions, model switches, and reboots. 11 primary layers injected into every context (episodic, semantic, procedural, visual, KG, behavioral, temporal, vector, working, goal-scoped, self-model) + 7 auxiliary layers running in background (learning examples, dream log, recovery memory, skill patterns, entity states, predictions, capabilities), all persisted in PostgreSQL and Redis.

MemoryManager

37 Built-in Skills

Your agent browses the web, runs code, sends emails, searches the internet, captures screenshots, and more, using real tool execution, not text simulation. Custom Python skills can be defined at runtime through natural language, and persist automatically across reboots.

SkillRegistry

Multi-Agent Orchestration

When a task is too complex for one agent, WASP creates a team. Named sub-agents run with isolated memory namespaces and capability sandboxes. MetaSupervisor decomposes complex goals into coordinated agent teams, automatically, without manual wiring.

AgentOrchestrator

Full Self-Modification

WASP can fix and improve itself, with no reboot, no redeploy. The agent reads, proposes, applies, and rolls back patches to its own source code at runtime. All changes persist across container rebuilds via automatic patch replay.

self_improve

Dream Mode

While you're offline, WASP works. During idle periods (1–7am), it consolidates episodic memory, extracts knowledge graph entities, runs LLM reflection on recent events, and pre-fetches context, so it's sharper when you return.

DreamJob

Multi-Provider LLM Routing

No vendor lock-in. WASP routes each task to the best available model across Anthropic, OpenAI, Google, xAI, Mistral, DeepSeek, Moonshot, OpenRouter, and local Ollama, automatically. If a context overflows, it recovers gracefully without losing output or breaking the task.

ModelManager

27 Background Scheduler Jobs

WASP never truly stops. 27 background jobs run continuously: consolidating memory, monitoring the world, detecting automation opportunities, validating every response, governing resources, and evolving new capabilities. No human supervision required.

Scheduler

Behavioral Learning Loop

Correct it once. It won't make the same mistake again. WASP detects corrections in real-time, analyzes them via LLM, extracts persistent behavioral rules, and injects them into every future prompt automatically. The agent that served you yesterday is already better today.

BehavioralLearner

Response Validation & Recovery

Every response is validated before delivery. Nine deterministic checks block hallucinations, price fabrication, grounding failures, and silent task omissions — with no LLM calls. If validation fails, a 2-attempt auto-recovery loop completes the missing work and re-validates before returning a safe, accurate answer.

ResponseValidator
Token Architecture

Engineered for
Efficiency

WASP does not rely on AI for every step. Routing, execution, and output validation happen deterministically, with no model calls, no latency, no cost. The LLM is invoked when it genuinely adds value. Everything else runs without it.

Decision Layer

Most requests never reach the LLM. A pre-model heuristic classifier with 13 fast-path patterns handles task lists, reminders, agent CRUD, model switching, and more, bypassing the model entirely. GOAL and SCHEDULED_TASK route directly to their handlers with zero tokens consumed.

5 strategies · direct dispatch

Capability Engine

Skills run through a deterministic validation layer before the model ever sees the result. Template validation, weighted scoring, output completeness checks, and safety validation, all without a model call. Validated successes are cached for reuse.

pre-LLM · zero model calls

Memory Reuse

The agent builds on what it already knows, not rediscovering it from scratch. Procedural memory, behavioral rules, and recovery patterns are injected into context. The model skips reasoning it has already done, reducing round count and avoiding redundant calls.

procedural · behavioral · recovery

Deterministic Output Layer

Output quality is verified without invoking the model again. After each LLM response, the Response Validator checks grounding, completeness, and drift, deterministically, with zero model calls. Auto-recovery runs only on confirmed failure, and only then calls the model a second time.

grounding · drift · completeness

Parallel Skill Execution

Multiple tools run at once, not one at a time. A single LLM round can trigger concurrent tool calls via <parallel> blocks and asyncio.gather(). Fewer round-trips means fewer total model invocations for the same outcome.

asyncio.gather · concurrent

Orchestration over Brute Force

Every LLM call moves execution forward, nothing is wasted. Rather than looping the model until something works, WASP uses structured DAG planning with a Plan Critic, budget enforcement (max 3 replans), and goal stability checks. Each invocation has a defined purpose and a defined exit.

DAG · budget · stability
System Architecture

Six Containers.
One Autonomous Brain.

Runs on any VPS or server with a single docker compose up. Each container has a single responsibility. Together, they form a complete autonomous cognitive system with zero cloud dependencies.

agent-core

The brain. Goal orchestration, skill execution, 18-layer memory, LLM routing, 27 background jobs, response validation, and the web dashboard on port 8080, all in a single container.

FastAPI · Quart · SQLAlchemy

agent-redis

The nervous system. Event bus via Redis Streams with consumer groups, handling real-time event delivery, state caching, ephemeral flags, circuit breaker state, and working memory.

Redis 7

agent-postgres

Long-term memory. 21 tables store everything that persists: episodic conversations, semantic facts, knowledge graph, procedural memory, behavioral rules, audit logs, world timeline, recovery patterns, and more.

PostgreSQL 16

agent-nginx

Reverse proxy with HTTPS termination. Handles TLS certificates, static assets, and routes all HTTP traffic to agent-core with zero configuration.

Nginx

agent-telegram

Polling bridge translating Telegram messages to Redis Stream events. Handles text, photos, videos, voice messages, and documents bidirectionally.

python-telegram-bot

agent-broker

Privileged root sidecar with Docker socket access. Exposes a strict allowlist of Docker operations (list/start/stop/logs/inspect) to the core container, with privileged access and contained scope.

Root sidecar
Initialization sequence: 20 ordered steps
01PostgreSQL + create_all
02MemoryManager
03ModelManager + providers
04SkillRegistry (37 skills)
05SkillExecutor + policy
06IdentityManager + prime.md
07IntegrationRegistry (40+)
08PlanGenerator + PlanCritic
09GoalOrchestrator
10AgentOrchestrator
11MetaSupervisor (optional)
12HealthMonitor + SelfHealer
13Introspector
14BrokerClient
15Scheduler (27 jobs)
16EventBus consumer group
17EventHandler wiring
18Dashboard server :8080
19Apply persisted patches
20Consumer loop: live
Memory System

18 Layers of
Cognitive Memory

WASP doesn't just store data. It builds a structured understanding over time. Every conversation, correction, and outcome feeds into 18 dedicated memory layers. 11 inject directly into every context turn. 7 run continuously in background, enriching the agent's knowledge without interrupting execution. All of it persists across sessions, reboots, and model switches.

01

Episodic Memory

Full conversation history in PostgreSQL with timestamps, chat IDs, and model metadata. Complete recall across all sessions.

02

Semantic Memory

Distilled facts, preferences, and important context extracted from conversations and stored as structured knowledge entries.

03

Procedural Memory

Multi-step solutions abstracted into named procedures with trigger keywords. Injected as few-shot hints for similar future tasks.

04

Visual Memory

Screenshots automatically indexed with metadata and descriptions. Enables cross-session visual reference without re-capturing.

05

Knowledge Graph

Rule-based entity and relationship extraction after every message. PostgreSQL-backed graph with Redis cache, injected per chat.

06

Behavioral Memory

User corrections trigger LLM rule extraction. Rules persist and inject into every future system prompt automatically.

07

Temporal Memory

World timeline tracking: crypto prices, user state changes, entity states. Trend detection and automated change alerts.

08

Vector Semantic Memory

Dense embeddings in PostgreSQL JSONB. Cosine similarity search across all memory types. No external vector DB required.

09

Working Memory

Redis-backed ephemeral state: active goals, reminders, subscriptions, task queues, dream state, CPI flags, budget tracking.

10

Goal-Scoped Memory

Observations isolated per active goal. Prevents cross-goal context pollution and injects only what's relevant to the current objective.

11

Self-Model & Epistemic State

Redis-backed living self-model: skill success rates, known failures, strengths, and per-domain confidence (0–1). Injected into every prompt so the agent knows what it knows.

Auxiliary Layers, Operating in Background

7 additional memory systems that run independently, enriching context without interrupting the main execution loop.

12

Learning Examples

Positive and negative few-shot training examples captured from user feedback. Injected as in-context examples to reinforce correct behavior patterns going forward.

13

Dream Log

Records from nightly offline consolidation sessions (DreamJob). Captures what was synthesized, promoted, and reflected during idle periods, never lost between runs.

14

Recovery Memory

Redis FIFO store (50 entries, 7-day TTL) of validated recovery patterns. Only successful recoveries are stored, with no noise. Reused automatically when a similar failure is detected. v2.2

15

Skill Patterns

SkillEvolutionEngine tracking of tool usage patterns, success rates, and composition opportunities. Drives autonomous capability evolution. New skills are generated from detected gaps.

16

Entity States

WorldModel structured tracking of real-world entities: crypto prices, user-defined monitored values, external service states. Updated by background perception and world model jobs.

17

State Predictions

TemporalReasoner trend summaries and directional predictions from historical entity data. Used to anticipate changes before they happen and trigger proactive alerts.

18

Reflection Memory

LLM insight after every goal completion or failure. Max 3 reflections per goal, 7-day TTL. Injected into future context so the agent learns what worked and what to avoid.

Skills & Tools

37 Built-in Skills
Ready to Execute

Every skill is real tool execution, not a text response. Each is policy-gated across 5 capability tiers, audit-logged with automatic secret redaction, and composable with other skills. Custom Python skills can be created at runtime through natural language, loaded immediately, and persisted across reboots.

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

27 Jobs Running
While You're Away

WASP doesn't wait for your input to be useful. These 27 jobs run continuously in the background, monitoring the world, consolidating memory, detecting automation opportunities, validating outputs, and evolving capabilities. Your agent stays sharp around the clock. Every job runs independently, with no single point of failure.

dreamevery 60min
perceptionevery 15min
behavioral_learnerevery 2min
autonomous_goalsevery 30min
subscription_checkerevery 5min
reminder_checkerevery 1min
health_monitorevery 5min
self_healerevery 5min
goal_tickevery 15s
agent_tickevery 15s
world_modelevery 30min
skill_evolutionevery 6h
self_integrityevery 6h
cpi_monitorevery 5min
epistemic_updatecontinuous
kg_extractorper message
temporal_modelper message
procedure_abstractper task
memory_promotein dream
introspectoron demand
circuit_breakerper call
audit_loggerevery skill
opportunity_engineevery 2h
self_reflectionper goal
capability_evolutionevery 60min
resource_governorper request
response_validatorper response
v2.1 → v2.2

Autonomous
Self-Evolution

Every interaction makes WASP better, not just for the current session, but permanently. Five systems let WASP detect its own gaps, seize automation opportunities, learn from every outcome, validate its own responses, and govern its resources, all without human intervention.

Capability Evolution Engine

If WASP can't do something, it learns how. When repeated failures or self-reflection detect a missing capability, CEE generates new tool code via LLM, validates it through a sandbox (AST parse + security blocklist + structural checks), and registers it into the live SkillRegistry, all at runtime, with no reboot needed.

CapabilityEvolutionEngine max 5/day · sandbox validated

Opportunity Engine

WASP notices what you repeat and offers to automate it. Every 2 hours, it scans episodic memory for patterns (3+ occurrences in 24h). When a clear opportunity is found, it surfaces the suggestion via Telegram, before you think to ask. Rate-limited with 48h dedup to avoid noise.

OpportunityEngine 2/day max · pattern-driven

Self-Reflection Engine

WASP learns from every goal, whether a success or a failure. After each completion, it asks the LLM for a learning insight: what worked, what failed, what to do differently. Up to 3 reflections per goal are stored in Redis and the most relevant ones injected into every future system prompt.

ReflectionEngine per goal · context-injected

Response Validation & Recovery

Every response is verified before it reaches you. A deterministic validator checks grounding, completeness, and drift. Zero LLM calls, zero false positives. On confirmed failure: 2-retry auto-recovery with real skill execution. Successful recoveries are stored in RecoveryMemory and reused automatically next time the same failure pattern appears.

ResponseValidator v2.2 · deterministic

Resource Governor

Autonomy without guardrails is a liability. Redis-backed rate limiting applies across every creation path: goals, agents, tasks, and LLM calls, per user, per minute, per hour. Graceful degradation on Redis failure (fail-open, never blocks). Prevents runaway autonomy while preserving full responsiveness under normal load.

ResourceGovernor fail-open · per-user TTL
LLM Providers

Any Model
Zero Lock-in

You're never tied to one provider. Switch at runtime with a single command, or just ask WASP to switch. Task-based routing picks the right model for each job automatically. If context overflows, it recovers without losing output or breaking execution.

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

Production-Grade
Security Hardening

You're not running an experiment. A 21-finding production security audit identified and fixed path traversal, SSRF, prompt injection, and CSRF vulnerabilities, all with regression tests. WASP is production-hardened by design.

Authentication & Rate Limiting

Argon2 password hashing, Redis-backed sessions with 24h TTL, 5-attempt rate limit with 5-minute lockout, full login audit logging.

CSRF Protection

Single-use tokens bound to authenticated sessions. Header-based X-CSRF-Token validation on all mutating requests. Anonymous session bypass fully blocked.

Path Traversal Prevention

os.path.realpath() throughout self_improve and skill evolution. Symlink traversal blocked. Strict containment with os.sep suffix checks.

SSRF Prevention

http_request skill blocks RFC-1918 private IPs, loopback, link-local, and cloud metadata endpoints (169.254.169.254) with full DNS resolution.

LLM Code Injection Defense

AST validation of all LLM-generated skill code. Blocks subprocess, eval, exec, ctypes, pickle, importlib. No class definition = auto-rejected.

Secret Redaction

All audit log entries auto-redacted for API keys: OpenAI sk-, Anthropic sk-ant-, Google AIza, Stripe sk_live, HuggingFace hf_, Bearer tokens, and more.

Capability Policy Engine

5 tiers: SAFE / MONITORED / CONTROLLED / RESTRICTED / PRIVILEGED. Agent-level sandbox allowlists. All skill executions audit-logged with redacted summaries.

Container Isolation

All app containers run as UID 1000 (non-root). Docker socket access only via agent-broker allowlist proxy. Privileged operations strictly gated and logged.

FAQ

Questions About
Autonomous AI Agents

Everything you need to know about running a self-hosted autonomous AI system.

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 takes this further with 18 layers of persistent memory, 27 background jobs, and a self-improvement loop.
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 18 layers of persistent memory across all sessions, runs 27 background jobs continuously, and improves its own behavior over time. It is a cognitive system, not a chat interface.
How is WASP different from OpenClaw?
WASP is a complete autonomous intelligence system, not just an agent framework. It adds 18-layer persistent memory, 27 autonomous background jobs, a pre-LLM Decision Layer routing 13 fast-path patterns before the model is invoked, deterministic Response Validation with auto-recovery, and a self-improvement loop that lets the agent evolve new capabilities at runtime, all production-hardened with a full security audit.
What is the 18-layer memory system?
WASP maintains 18 memory layers: 11 primary layers injected into every context (episodic, semantic, procedural, visual, knowledge graph, behavioral rules, temporal world model, vector embeddings, working memory, goal-scoped memory, self-model) and 7 auxiliary layers in background (learning examples, dream log, recovery memory, skill patterns, entity states, state predictions, reflection memory). All persists in PostgreSQL and Redis across sessions and reboots.
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. 27 background jobs keep the agent active 24/7, even when you're offline.
What is a self-hosted AI agent?
A self-hosted AI agent runs entirely on infrastructure you control, whether your own VPS, server, or private cloud. WASP deploys with a single docker compose up. All data, including memory, goals, audit logs, and behavioral rules, stays on your machines. You connect your own LLM API keys. No vendor accesses your conversations or agent state.
What tools and integrations are included?
37 built-in skills: web browser (Chromium, persistent sessions), web search, shell execution, Python runtime, Gmail, Slack, Discord, file I/O, HTTP requests, crypto price monitoring, memory search, agent management, and more. WASP also connects to 40+ external integrations and supports custom Python skills created at runtime through natural language, loaded and persisted automatically.
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.
● Open Source · Self-Hosted · Zero Cloud Lock-in

Run Your Own
Autonomous Intelligence

One VPS or local machine, one docker compose up, and your agent is live in minutes with full cognitive autonomy.

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

Star on GitHub Read the Docs
# Three commands to full autonomy
git clone https://github.com/your-org/agent-wasp
cp .env.example .env # add your LLM API key
docker compose up -d
# Dashboard → https://localhost ✓