Autensa

The World's First Autonomous Product Engine
autensa.com

Your products improve themselves — 24/7 — while you sleep.
Research → Ideation → Swipe → Build → Test → Review → Pull Request — fully automated.

I highly recommend getting Hetzner VPS to run this. You can sign up here.

🎮 Live Demo • Quick Start • Docker • What's New • Features • How It Works • Configuration • Contributors

▶️ Watch the Autensa v2 Introduction

---

🚀 What's New in v2.0.1

New Features

• Product Settings Modal — Gear icon (⚙️) in the product dashboard header. Edit name, description, repo URL, live URL, branch, build mode, and icon inline — no more manual DB updates.
• Import README in New Product Wizard — One-click import of your repo's README.md to pre-populate the Product Program. Works with public repos (GitHub API) and private repos (local filesystem fallback).
• Auto-Generate Description — AI generates a concise product description from your repo README and live site content via the OpenClaw Gateway.
• Smarter Private Repo Handling — Repo validation now explicitly tells users a repo may be private instead of a generic "could not verify" warning.

Stability & Community Contributions

• Dispatch hang fix — All dispatch calls now have a 30s timeout. Previously, a slow OpenClaw gateway could hang the server indefinitely during stage transitions (testing/review/verification). Failed dispatches also force-reconnect the WebSocket so retries start fresh.
• Fresh markdown in Agent Modal — The modal now fetches live data from the API instead of showing stale store cache.
• Pre-migration database backups — Automatic timestamped backups before migrations using VACUUM INTO. Keeps last 5. (@cgluttrell)
• Migration 013 data guard — The destructive "fresh start" migration now skips databases with existing data. (@cgluttrell)
• Static device identity path — Removes dynamic filesystem path parameter. (@org4lap)

v2.0 Highlights

Autensa v2 is a ground-up expansion from task orchestration dashboard to the world's first autonomous product improvement engine. It researches your market, generates feature ideas, lets you decide with a swipe, and builds them — automatically.

🔬 Product Autopilot — The Full Pipeline

The headline feature. Point Autensa at any product (repo + live URL) and it runs a continuous improvement loop:

1. Autonomous Research — AI agents analyze your codebase, scan your live site, and research your market: competitors, user intent, conversion patterns, SEO gaps, technical opportunities. Runs on configurable schedules — daily, weekly, or on-demand.

2. AI-Powered Ideation — Research feeds into ideation agents that generate concrete, scored feature ideas. Each idea includes an impact score, feasibility score, size estimate, technical approach, and a direct link to the research that inspired it.

3. Swipe to Decide — Ideas appear as cards in a Tinder-style interface. Four actions:

   • Pass — Rejected. The preference model learns from it.
   • Maybe — Saved to the Maybe Pool. Resurfaces in 1 week with fresh context.
   • Yes — Task created. Build agent starts coding.
   • Now! — Urgent dispatch. Priority queue, immediate execution.

4. Automated Build → PR — Approved ideas flow through the full agent pipeline: Build agent implements the feature → Test agent runs the suite → Review agent inspects the diff → Pull request created on GitHub with full context.

Your only job is the swipe. Everything else is automated.

📄 Product Program (Karpathy AutoResearch Pattern)

Inspired by Andrej Karpathy's AutoResearch architecture. Each product has a Product Program — a living document that instructs research and ideation agents on what to look for, what matters, and what to ignore. The program evolves as swipe data accumulates: the system learns your taste, not just patterns.

🚛 Convoy Mode — Parallel Multi-Agent Execution

Large features get decomposed into subtasks with a visual dependency graph (DAG). Multiple agents (3–5) work simultaneously with dependency-aware scheduling:

• Parallel subtask execution — Independent pieces run concurrently
• Dependency graph visualization — See what depends on what
• Health monitoring — Detects stalled, stuck, or zombie agents automatically
• Auto-nudge — Reassigns or restarts agents that go dark
• Crash recovery — Checkpoints save agent progress; work resumes from last checkpoint, not from scratch

💬 Operator Chat — Talk to Agents Mid-Build

Don't wait for a PR to give feedback. Two communication modes:

• Queued Notes — Add context ("use the existing auth middleware") that gets delivered at the agent's next checkpoint
• Direct Messages — Delivered immediately to the agent's active session for real-time course correction

Full chat history preserved per task — every message, note, and response.

💰 Cost Tracking & Budget Caps

Granular spend visibility across every dimension:

• Per-task cost tracking — See exactly what each feature costs to build
• Per-product aggregation — Total spend across all tasks for a product
• Daily and monthly caps — Set budget limits that auto-pause dispatch when exceeded
• Cost breakdown API — Detailed reports by agent, model, and time period

🧠 Knowledge Base & Learner Agent

A dedicated Learner agent captures lessons from every build cycle — what worked, what failed, what patterns emerged. Knowledge entries are injected into future dispatches so agents don't repeat mistakes.

📋 Enhanced Planning Phase

Before any build starts, agents run a structured planning phase:

• AI asks clarifying questions about requirements and constraints
• Generates a detailed spec from your answers
• Multi-agent planning specs with sub-agent definitions and execution steps
• Approval gate — you review the plan before any code is written

🔄 Checkpoint & Crash Recovery

Agent progress is saved at configurable checkpoints:

• If a session crashes, work resumes from the last checkpoint — not from scratch
• Checkpoint restore API for manual recovery
• Checkpoint history visible per task

🎯 Preference Learning

Every swipe trains a per-product preference model:

• Category weights (growth, SEO, UX, etc.) adjust based on approvals/rejections
• Complexity preferences calibrate over time
• Tag pattern recognition refines idea generation
• Ideas get sharper with every iteration

🔁 Maybe Pool

Ideas you're not sure about don't disappear:

• Swiped "Maybe" ideas enter a holding pool
• Automatically resurface after a configurable period with new market context
• Batch re-evaluation mode to review accumulated maybes
• Can be promoted to Yes at any time

📡 Live Activity Feed

Real-time SSE stream of everything happening across all products:

• Research progress, ideation cycles, swipe events
• Build progress, test results, review outcomes
• Agent health events, cost updates, PR creation
• Filterable by product, agent, and event type

🛡️ Automation Tiers

Choose your comfort level per product:

Tier	Behavior	Best For
Supervised	PRs created automatically. You review and merge manually.	Production apps
Semi-Auto	PRs auto-merge when CI passes and review agent approves.	Staging & trusted repos
Full Auto	Everything automated end-to-end. Idea → deployed feature.	Side projects & MVPs

🔀 Workspace Isolation

Each build task gets an isolated workspace:

• Git Worktrees for repo-backed projects — isolated branch, no conflicts with other agents
• Task Sandboxes for local/no-repo projects — dedicated directory under .workspaces/task-{id}/
• Port allocation (4200–4299 range) for dev servers — no port conflicts between concurrent builds
• Serialized merge queue — completed tasks merge one at a time with conflict detection
• Product-scoped locking — concurrent completions for the same product queue automatically

📊 Product Scheduling

Configure autonomous cycles per product:

• Research frequency (daily, weekly, custom cron)
• Ideation frequency (after each research cycle, or independent schedule)
• Auto-dispatch rules (immediate on "Yes" swipe, or batch)
• Schedule management UI with enable/disable per schedule

---

✨ Features

Product Autopilot

• 🔬 Autonomous market research (competitors, SEO, user intent, technical gaps)
• 💡 AI-powered ideation with impact/feasibility scoring
• 👆 Swipe interface for instant approve/reject/maybe decisions
• 📄 Product Program (Karpathy AutoResearch pattern)
• 🎯 Preference learning from swipe history
• 🔁 Maybe Pool with auto-resurface
• 📊 Configurable research & ideation schedules

Agent Orchestration

• 🤖 Multi-agent pipeline (Builder → Tester → Reviewer → Learner)
• 🚛 Convoy Mode for parallel multi-agent execution
• 💬 Operator Chat (queued notes + direct messages)
• 💚 Agent health monitoring with auto-nudge
• 🔄 Checkpoint & crash recovery
• 🧠 Knowledge base with cross-task learning
• 🔀 Workspace isolation (git worktrees + task sandboxes)

Task Management

• 🎯 Kanban board with drag-and-drop across 7 status columns
• 🧠 AI planning phase with clarifying Q&A
• 📋 Multi-agent planning specs
• 🖼️ Task image attachments (UI mockups, screenshots)
• 📡 Live real-time activity feed (SSE)
• 💰 Per-task, per-product, daily/monthly cost tracking & caps

Infrastructure

• 🔌 OpenClaw Gateway integration (WebSocket)
• 🔗 Gateway agent discovery & import
• 🐳 Docker ready (production-optimized)
• 🔒 Bearer token auth, HMAC webhooks, Zod validation
• 🛡️ Privacy first — no trackers, no centralized data collection
• 🌐 Multi-machine support (Tailscale compatible)
• 🛡️ Automation tiers (Supervised / Semi-Auto / Full Auto)

---

🛡️ Privacy

Autensa is open-source and self-hosted. The project does not include ad trackers, third-party analytics beacons, or a centralized data collector.

Your task data, research results, ideas, swipe history, and product programs stay in your own deployment (SQLite + workspace). If you connect external services (AI providers or remote gateways), only the data you explicitly send to those services leaves your environment.

---

🏗 Architecture

┌──────────────────────────────────────────────────────────────────────┐
│                          YOUR MACHINE                                │
│                                                                      │
│  ┌──────────────────┐          ┌──────────────────────────────────┐  │
│  │ Autensa           │◄────────►│    OpenClaw Gateway              │  │
│  │  (Next.js)        │   WS     │  (AI Agent Runtime)              │  │
│  │  Port 4000        │          │  Port 18789                      │  │
│  └────────┬──────────┘          └───────────┬────────────────────┘  │
│           │                                  │                       │
│           ▼                                  ▼                       │
│  ┌──────────────────┐          ┌──────────────────────────────────┐  │
│  │    SQLite DB       │          │     AI Providers                │  │
│  │  (tasks, products, │          │  (Anthropic / OpenAI / etc.)    │  │
│  │   ideas, costs)    │          └──────────────────────────────────┘  │
│  └──────────────────┘                                                │
│           │                                                          │
│           ▼                                                          │
│  ┌──────────────────────────────────────────────────────────────┐   │
│  │              Autopilot Engine                                  │   │
│  │  Research → Ideation → Swipe → Build → Test → Review → PR     │   │
│  └──────────────────────────────────────────────────────────────┘   │
└──────────────────────────────────────────────────────────────────────┘

Autensa = The dashboard + autopilot engine (this project) OpenClaw Gateway = The AI runtime that executes tasks (separate project)

---

🚀 Quick Start

Prerequisites

• Node.js v18+ (download)
• OpenClaw Gateway — npm install -g openclaw
• AI API Key — Anthropic (recommended), OpenAI, Google, or others via OpenRouter

Install

# Clone
git clone https://github.com/crshdn/mission-control.git
cd mission-control

# Install dependencies
npm install

# Setup
cp .env.example .env.local

Edit .env.local:

OPENCLAW_GATEWAY_URL=ws://127.0.0.1:18789
OPENCLAW_GATEWAY_TOKEN=your-token-here

Where to find the token: Check ~/.openclaw/openclaw.json under gateway.token

Run

# Start OpenClaw (separate terminal)
openclaw gateway start

# Start Autensa
npm run dev

Open http://localhost:4000 — you're in! 🎉

Production

npm run build
npx next start -p 4000

---

🐳 Docker

You can run Autensa in a container using the included Dockerfile and docker-compose.yml.

Prerequisites

• Docker Desktop (or Docker Engine + Compose plugin)
• OpenClaw Gateway running locally or remotely

1. Configure environment

Create a .env file for Compose:

cp .env.example .env

Then set at least:

OPENCLAW_GATEWAY_URL=ws://host.docker.internal:18789
OPENCLAW_GATEWAY_TOKEN=your-token-here

Notes:

• Use host.docker.internal when OpenClaw runs on your host machine.
• If OpenClaw is on another machine, set its reachable ws:// or wss:// URL instead.

2. Build and start

docker compose up -d --build

Open http://localhost:4000.

3. Useful commands

# View logs
docker compose logs -f mission-control

# Stop containers
docker compose down

# Stop and remove volumes (deletes SQLite/workspace data)
docker compose down -v

Data persistence

Compose uses named volumes:

• mission-control-data for SQLite (/app/data)
• mission-control-workspace for workspace files (/app/workspace)

---

🎯 How It Works

The Autopilot Pipeline

RESEARCH → IDEATION → SWIPE → PLAN → BUILD → TEST → REVIEW → PR
   AI          AI      You      AI     Agent   Agent   Agent   Auto

1. Research — AI analyzes your product's market: competitors, SEO, user intent, technical gaps
2. Ideation — Research feeds ideation agents that generate scored feature ideas
3. Swipe — You review ideas as cards. Pass / Maybe / Yes / Now!
4. Plan — AI asks clarifying questions, generates a detailed spec
5. Build — Agent clones repo, creates branch, implements the feature
6. Test — Agent runs the test suite. Failures bounce back for auto-fix
7. Review — Agent inspects the diff for quality, security, best practices
8. PR — Pull request created on GitHub with full context and research backing

Task Flow (Manual Tasks)

PLANNING → INBOX → ASSIGNED → IN PROGRESS → TESTING → REVIEW → DONE

Drag tasks between columns or let the system auto-advance them.

Convoy Mode (Large Features)

                    ┌─ Subtask A (Agent 1) ──┐
PARENT TASK ────────┤                        ├──── MERGE & PR
                    ├─ Subtask B (Agent 2) ──┤
                    └─ Subtask C (Agent 3) ──┘
                         (depends on A)

Subtasks run in parallel with dependency-aware scheduling. Health monitoring detects stalls. Crash recovery via checkpoints.

---

⚙️ Configuration

Environment Variables

Variable	Required	Default	Description
OPENCLAW_GATEWAY_URL	✅	ws://127.0.0.1:18789	WebSocket URL to OpenClaw Gateway
OPENCLAW_GATEWAY_TOKEN	✅	—	Authentication token for OpenClaw
MC_API_TOKEN	—	—	API auth token (enables auth middleware)
WEBHOOK_SECRET	—	—	HMAC secret for webhook validation
DATABASE_PATH	—	./mission-control.db	SQLite database location
WORKSPACE_BASE_PATH	—	~/Documents/Shared	Base directory for workspace files
PROJECTS_PATH	—	~/Documents/Shared/projects	Directory for project folders

Security (Production)

Generate secure tokens:

# API authentication token
openssl rand -hex 32

# Webhook signature secret
openssl rand -hex 32

Add to .env.local:

MC_API_TOKEN=your-64-char-hex-token
WEBHOOK_SECRET=your-64-char-hex-token

When MC_API_TOKEN is set:

• External API calls require Authorization: Bearer <token>
• Browser UI works automatically (same-origin requests are allowed)
• SSE streams accept token as query param

See PRODUCTION_SETUP.md for the full production guide.

---

🌐 Multi-Machine Setup

Run Autensa on one machine and OpenClaw on another:

# Point to the remote machine
OPENCLAW_GATEWAY_URL=ws://YOUR_SERVER_IP:18789
OPENCLAW_GATEWAY_TOKEN=your-shared-token

With Tailscale (Recommended)

OPENCLAW_GATEWAY_URL=wss://your-machine.tailnet-name.ts.net
OPENCLAW_GATEWAY_TOKEN=your-shared-token

---

🗄 Database

SQLite database auto-created at ./mission-control.db. Migrations run automatically on startup (21 migrations). As of v2.0.1, a timestamped backup is created before any pending migration runs.

# Reset (start fresh)
rm mission-control.db

# Inspect
sqlite3 mission-control.db ".tables"

Key tables added in v2: products, research_cycles, ideas, swipe_history, preference_models, maybe_pool, product_feedback, cost_events, cost_caps, product_schedules, operations_log, convoys, convoy_subtasks, agent_health, work_checkpoints, agent_mailbox, workspace_ports, workspace_merges.

---

📁 Project Structure

autensa/
├── src/
│   ├── app/                    # Next.js pages & API routes
│   │   ├── api/
│   │   │   ├── tasks/          # Task CRUD, planning, dispatch, convoy, chat, workspace
│   │   │   ├── products/       # Product CRUD, research, ideation, swipe, schedules
│   │   │   ├── agents/         # Agent management, health, mail, discovery
│   │   │   ├── costs/          # Cost tracking, caps, breakdowns
│   │   │   ├── convoy/         # Convoy mail endpoints
│   │   │   ├── openclaw/       # Gateway proxy endpoints
│   │   │   └── webhooks/       # Agent completion webhooks
│   │   ├── settings/           # Settings page
│   │   └── workspace/[slug]/   # Workspace dashboard
│   ├── components/
│   │   ├── MissionQueue.tsx    # Kanban board
│   │   ├── PlanningTab.tsx     # AI planning interface
│   │   ├── AgentsSidebar.tsx   # Agent panel
│   │   ├── LiveFeed.tsx        # Real-time events
│   │   ├── TaskModal.tsx       # Task create/edit
│   │   ├── TaskChatTab.tsx     # Operator chat
│   │   ├── ConvoyTab.tsx       # Convoy visualization
│   │   ├── DependencyGraph.tsx # DAG visualization
│   │   ├── HealthIndicator.tsx # Agent health badges
│   │   ├── WorkspaceTab.tsx    # Workspace isolation UI
│   │   ├── autopilot/          # SwipeDeck, IdeaCard, ResearchReport, etc.
│   │   └── costs/              # Cost dashboard components
│   └── lib/
│       ├── autopilot/          # Research, ideation, swipe, maybe-pool, scheduling
│       ├── costs/              # Cost tracker, caps, reporting
│       ├── db/                 # SQLite + 21 migrations
│       ├── openclaw/           # Gateway client + device identity
│       ├── convoy.ts           # Convoy orchestration
│       ├── agent-health.ts     # Health monitoring + auto-nudge
│       ├── checkpoint.ts       # Checkpoint save/restore
│       ├── workspace-isolation.ts # Git worktrees + task sandboxes
│       ├── mailbox.ts          # Inter-agent messaging
│       ├── chat-listener.ts    # Operator chat relay
│       ├── learner.ts          # Knowledge base management
│       └── types.ts            # TypeScript types
├── presentation/               # v2 pitch deck + narration script
├── specs/                      # Feature specs
├── scripts/                    # Bridge & hook scripts
└── CHANGELOG.md                # Full version history

---

🔧 Troubleshooting

Can't connect to OpenClaw Gateway

1. Check OpenClaw is running: openclaw gateway status
2. Verify URL and token in .env.local
3. Check firewall isn't blocking port 18789

Planning questions not loading

1. Check OpenClaw logs: openclaw gateway logs
2. Verify your AI API key is valid
3. Refresh and click the task again

Port 4000 already in use

lsof -i :4000
kill -9 <PID>

Agent callbacks failing behind a proxy (502 errors)

If you're behind an HTTP proxy (corporate VPN, Hiddify, etc.), agent callbacks to localhost may fail because the proxy intercepts local requests.

Fix: Set NO_PROXY so localhost bypasses the proxy:

# Linux / macOS
export NO_PROXY=localhost,127.0.0.1

# Windows (cmd)
set NO_PROXY=localhost,127.0.0.1

# Docker
docker run -e NO_PROXY=localhost,127.0.0.1 ...

See Issue #30 for details.

---

🤝 Contributing

1. Fork the repository
2. Create a feature branch: git checkout -b feature/amazing-feature
3. Commit your changes: git commit -m 'feat: add amazing feature'
4. Push: git push origin feature/amazing-feature
5. Open a Pull Request

---

👏 Contributors

Autensa is built by a growing community. Thank you to everyone who has contributed!

Steve Device Identity	Ryan Christman Port Configuration	nicozefrench ARIA Hooks	GOPAL Node v25 Support
Jorge Martinez Orchestration	Nik Planning & Dispatch	Michael G Usage Dashboard	Z8Medina Metabase Integration
Mark Phelps Gateway Agent Discovery 💡	Alessio Docker Support	James Tsetsekas Planning Flow Fixes	nice-and-precise Agent Protocol Docs
JamesCao2048 Task Creation Fix	davetha Force-Dynamic & Model Discovery	pkgaiassistant-droid Activity Dashboard & Mobile UX	Coder-maxer Static Route Fix
grunya-openclaw Dispatch & Proxy Bug Reports	ilakskill Dispatch Recovery Design	plutusaisystem-cmyk Agent Daemon & Fleet View	nithis4th 2nd Brain Knowledge Base
davidpellerin Dynamic Agent Config	tmchow Agent Import Improvements	xiaomiusa87 Session Key Bug Report	lutherbot-ai Security Audit
YITING OU Cascade Delete Fix	Brandon Ros Docker CI Workflow	nano-lgtm Kanban UX Improvements	cammybot1313-collab Docs Typo Fix

---

⭐ Star History

---

📜 License

MIT License — see LICENSE for details.

---

🙏 Acknowledgments

• Andrej Karpathy — AutoResearch architecture that inspired the Product Program pattern
• Mike De'Shazer — Operator Chat concept

---

☕ Support

If Autensa has been useful to you, consider buying me a coffee!

---

Stop managing a backlog. Start shipping on autopilot. 🚀