VisionClaw Agent

Built for agencies, operators, and founders who want an always-on AI operations team they own and host themselves.

Created by Robert Washburn | huskyauto@gmail.com | Live demo: example.com

Not affiliated with the unrelated AR/wearable "VisionClaw" project. This is the AI agent platform.

VisionClaw Agent is an open-source, multi-tenant AI platform where 16 specialized agents work together to produce real deliverables — research reports, legal documents, financial models, marketing campaigns, slide decks, spreadsheets, and PDFs.

Instead of a single chatbot, you get a full agent workforce. Give it a task. The right agent picks it up, selects the right tools, coordinates with other agents when needed, and delivers a finished result. Every decision is traceable, every action is governed, and every integration degrades gracefully when not configured.

Fork it. Configure your API keys. Deploy. You have an AI operations team.

The app runs with just one LLM key and a Postgres database. Everything else — email, payments, voice, Drive — is optional and appears automatically when you add the key.

Over 147k lines of TypeScript across 348 files. 40+ pages. 220 tools. 62 skills. 37+ AI models. 6 providers. 130 tables. 40 governance rules.

Platform	One-click
Replit	Open in Replit →
Render
Railway
Docker	docker compose up — see FORK-SETUP.md

After deploy, you'll need a Postgres database with the vector extension (Render and Railway can provision one for you), one LLM key (OPENAI_API_KEY or ANTHROPIC_API_KEY), and a SESSION_SECRET. Everything else is optional.

Landing page with live agent activity feed and command center stats

First-run setup dashboard — real-time status of every integration

Once you're set up, paste any of these into the chat to see the platform in action:

Real screenshots from the live instance at example.com.

Landing hero — value prop in one line, with three real CTAs.	Command Center — live counts, recent ops with status pills, capability chips.
Agent Activity Feed — Neptune ships research, Luna runs compliance, Cassandra builds the Excel model, Felix delivers the styled PDF.	Mixture of Agents — 4 frontier proposers (Sonnet · GPT-4.1 · Gemini 2.5 Pro · DeepSeek Reasoner) feed a Claude Opus aggregator for ensemble-quality answers.
Gated Code Proposals (R25) — nightly research generates real edits; a shadow verifier compiles each in an isolated git worktree before any human reviewer sees it.	Glasses Gateway — Meta Ray-Ban smart glasses stream POV video and audio to a tenant-isolated gateway with sub-second voice replies via Gemini Live.

  User Request
       │
       ▼
┌──────────────────┐     ┌─────────────────────────────┐
│   Chat Engine    │────▶│   Agent Router              │
│  (SSE streaming) │     │   picks best agent for task  │
└──────────────────┘     └──────────┬──────────────────┘
                                   │
                    ┌──────────────┼──────────────┐
                    ▼              ▼              ▼
              ┌──────────┐  ┌──────────┐  ┌──────────┐
              │  Felix   │  │ Minerva  │  │ Neptune  │  ... 16 agents
              │  (CEO)   │  │(Strategy)│  │(Research)│
              └────┬─────┘  └────┬─────┘  └────┬─────┘
                   │             │              │
                   ▼             ▼              ▼
            ┌─────────────────────────────────────────┐
            │          226 Tools                      │
            │  Search · Write · Build · Analyze ·     │
            │  Email · Pay · Generate · Research       │
            └──────────────────┬──────────────────────┘
                               │
              ┌────────────────┼────────────────┐
              ▼                ▼                ▼
        ┌──────────┐   ┌────────────┐   ┌────────────┐
        │ PostgreSQL│   │ Google     │   │ 6 AI       │
        │ + pgvector│   │ Drive      │   │ Providers  │
        │ 130 tables│   │ Storage    │   │ 37+ models │
        └──────────┘   └────────────┘   └────────────┘

Example flow: You say "Research competitor pricing and build me a comparison spreadsheet."

1. The Chat Engine routes to Felix (CEO) who sees this needs research + document production
2. Felix spawns Radar (Intelligence) to research competitors and Atlas (Metrics) to structure the data
3. Radar uses web search and scraping tools, deposits findings into the knowledge base
4. Atlas pulls findings, builds a formatted Excel spreadsheet, uploads to Google Drive
5. You get back a summary with a download link — no manual steps

Every agent has a defined role, personality, skill set, and operating rules. They work independently or collaborate through orchestration engines.

• 37+ AI Models with cost-aware auto-routing across OpenAI, Anthropic, Google Gemini, xAI Grok, OpenRouter, and Perplexity
• Subscription-First Routing — connect your existing ChatGPT Plus or Gemini Advanced subscription via OAuth to use for inference at $0 API cost
• Streaming Responses via Server-Sent Events (SSE) — real-time token-by-token output
• Thinking Mode — explainable reasoning with decision traces for complex problems
• Model Failover — automatic fallback to healthy providers when one goes down
• Context Window Management — automatic conversation compaction that preserves every fact before summarizing

• PDF Reports — executive-quality styled PDFs with cover pages, branded headers/footers, charts, and tables
• Word Documents (.docx) — professional documents with formatting, headers, and styles
• Excel Spreadsheets (.xlsx) — auto-formatted workbooks with formulas and conditional formatting
• Google Slides — automated presentation generation delivered to Google Drive
• Charts & Diagrams — Recharts visualizations and Mermaid.js diagrams rendered to PNG
• PDF Form Filling — fill existing PDF forms programmatically
• Invoices — professional invoices with line items, taxes, and branding

• Autonomous Overnight Research — configurable research programs that run autonomously, with LLM-judged experiment scoring and auto-deposit of findings into your knowledge base
• Web Search — powered by Perplexity with Wikipedia and Jina fallbacks
• Deep Web Scraping — Firecrawl integration for full-site crawling and markdown extraction
• Trend Research — parallel scanning across Reddit, Hacker News, Polymarket, and X/Twitter
• Competitive Intelligence — automated competitor analysis with structured output

• Semantic Memory Palace — hierarchical memory organized by Wing and Room with three-tier recall (Hot/Warm/Cold)
• Zero-Loss Compaction — full pre-compaction transcripts archived and recoverable; every fact extracted before conversation summarization
• Vector Knowledge Base — RAG-powered knowledge retrieval with MMR diversity re-ranking
• Temporal Knowledge — subject-predicate-object facts with time validity tracking
• Dialectic User Modeling — three internal agents (Deriver, Dialectic, Dreamer) progressively build a profile of each user from conversations

• Crews — agent teams with defined roles, goals, and backstories working toward a shared objective
• Flows — event-driven workflow pipelines that chain agent actions
• Minds — 4-role deliberation system (Proposer, Critic, Synthesizer, Judge) for complex decisions
• Auto-Orchestration — the COO automatically decomposes complex requests into DAG task graphs and delegates to specialists
• Subagent Spawning — agents can spawn child agents for sub-tasks with full tool access
• Chain of Debates — multi-persona deliberation where 3-6 specialists argue complex questions from different perspectives

• Email — built-in email server with tenant-specific inboxes, send/reply, and notification handling
• WhatsApp — full bot integration for sending/receiving messages and approval workflows
• Telegram — bot integration for external interaction
• Discord — bot integration for team communication
• Google Workspace — Gmail, Calendar, Sheets, Docs, Slides, and Contacts integration
• Google Drive — primary storage for generated deliverables; every project gets a dedicated Drive folder with automatic backup

• Stripe — subscription management, checkout sessions, usage billing, and customer portal
• Stripe Connect — tenants can connect their own Stripe accounts for white-label payment processing
• Coinbase Commerce — cryptocurrency payments via hosted checkout
• Coinbase CDP — on-chain wallet management and balance checks
• Usage Metering — token tracking and feature access limits tied to billing tiers

• Text-to-Speech — ElevenLabs integration with 23+ voice profiles
• Voice Conversations — real-time voice input/output with configurable wake words
• Image Generation — DALL-E and Replit AI image generation
• Video Production — scene-based MP4 pipeline with parallel TTS, Ken Burns motion, 25+ transitions, and background music

• Project Brain — filing cabinet system linking conversations, files, notes, and Google Drive assets to projects
• Scheduled Tasks — cron-like automation for recurring agent work
• Activity Logging — comprehensive system-wide activity tracking
• Agent Board — visual overview of all agent activities and status

• 40 Governance Rules — built-in rules controlling agent autonomy and behavior
• Process Governor — enforces execution limits and approval requirements
• Trust Engine — evaluates safety and reliability of tool calls; high-risk actions require human approval
• Prompt Injection Scanner — detects and blocks malicious injection attempts
• 3-Layer Failure Recovery:
  1. Self-correction retry with adjusted parameters
  2. Lean mode fallback to a lighter model on overload
  3. Backup agent reroute to mapped specialist
  4. 5-part failure transparency (what failed, why, what was tried, what succeeded, what the user should know)
• Critique Agent — every response auto-evaluated on accuracy, completeness, relevance, and clarity (scored 1-10); low scores trigger auto-refinement

• Full Tenant Isolation — each tenant has separate conversations, memory, projects, files, settings, and billing
• Per-Tenant WhatsApp/Email/Payment — communication and payment channels isolated by tenant
• Team Management — invite users, manage roles, and control access
• API Keys — per-tenant API key management for external integrations

• Settings Dashboard — comprehensive admin panel with tabs for General, Payments, Integrations, Voice, Tools, Security, Data, and Tenants
• Diagnostics — stuck task detection, health monitoring, provider latency testing
• Heartbeat Engine — system health monitoring with configurable check intervals
• Auto-Tuner — autonomous performance optimization that runs daily
• Webhook System — inbound/outbound webhook triggers for external automation
• MCP Server — Model Context Protocol server for AI tool integration
• Backup & Restore — automated daily backups to Google Drive with manual export/import
• Vault — secure credential storage for sensitive data

client/                       # React frontend
  src/
    pages/                    # 40+ route pages
    components/               # Reusable UI components (shadcn/ui)
    hooks/                    # Custom React hooks
    lib/                      # Utilities, query client, API helpers
server/                       # Express backend
  chat-engine.ts              # Core AI conversation engine with streaming
  tools.ts                    # 226 tool definitions and execution handlers
  routes.ts                   # 300+ API endpoints
  site-config.ts              # Centralized env-driven configuration
  seed.ts                     # Database seeding (130 tables, 40 rules, 16 personas)
  heartbeat.ts                # Background task scheduler
  agent-manager.ts            # Autonomous agent orchestration
  subagents.ts                # Hierarchical agent spawning
  agent-channels.ts           # Internal agent messaging system
  google-drive.ts             # Google Drive integration
  stripe-connect.ts           # Stripe payment processing
  coinbase-commerce.ts        # Crypto payment processing
  whatsapp.ts                 # WhatsApp bot integration
  email.ts                    # Email server and tenant inboxes
  scaffolding.ts              # 75 corporate operation scaffolds
shared/
  schema.ts                   # Drizzle ORM schema (113 tables)
scripts/
  clean-for-release.sh        # Sanitize codebase for public release
FORK-SETUP.md                 # Detailed setup instructions

• Node.js 20+ (or a Replit account)
• PostgreSQL database
• At least one AI provider API key (OpenAI, Anthropic, Google, or xAI)

# 1. Clone the repo
git clone https://github.com/Huskyauto/VisionClaw-Agent-Public-Release.git
cd VisionClaw-Agent-Public-Release

# 2. Install dependencies
npm install

# 3. Set required environment variables
export DATABASE_URL="postgresql://user:pass@host:5432/dbname"
export SESSION_SECRET="$(openssl rand -hex 32)"
export OPENAI_API_KEY="sk-..."   # Or ANTHROPIC_API_KEY, XAI_API_KEY, etc.

# 4. Start the platform
npm run dev

# 5. Open your browser
# Visit http://localhost:5000
# Fresh deploys auto-redirect to /setup

In under 10 minutes, you go from git clone to a live dashboard with 16 agents, seeded governance, and a /setup checklist that tells you exactly what's configured and what's missing.

1. The database auto-creates all 130 tables and full index set
2. 40 governance rules and 16 AI personas are seeded automatically
3. You're redirected to the Setup Checklist at /setup showing what's configured
4. Click Create Account — the first account becomes the admin
5. Start chatting — the AI is ready to work

See FORK-SETUP.md for the complete list. Here's the quick reference:

Features that aren't configured don't break the app — they gracefully disappear:

The /setup page gives you a real-time checklist showing exactly what's configured and what's not.

Once logged in as admin, the Settings page (/settings) gives you control over everything:

The platform includes 40+ pages organized by function:

Core: Home, Chat, Inbox, Email, Projects, Files, Documents

AI Management: Personas, Memory, Knowledge, Skills, Skills Marketplace, Agent Board, Agentic Operations

Intelligence: Research, Insights, Content Writing, Scheduled Tasks

Communication: WhatsApp, Telegram, Discord (with approval workflows)

Admin: Settings, Analytics, Activity Logs, Heartbeat, Team, API Keys, MCP, Webhooks, Channel Routing, Payments

Public: Landing Page, Architecture Overview, Login/Signup, Legal Pages (Terms, Privacy, About, Contact, Refund)

These are the patterns we actually use in daily production — not just research papers:

1. Parallel Tool Execution — read-only tools run concurrently via Promise.all; mutating tools execute sequentially for causal ordering
2. Critique Agent / Self-Correction — every response auto-evaluated across 4 dimensions (accuracy, completeness, relevance, clarity); scores below 6/10 trigger auto-refinement
3. Chain of Debates — 3-6 specialist agents argue complex questions from their domain expertise; synthesizes a recommendation with consensus level
4. Tree-of-Thought Reasoning — 2-5 distinct analytical branches evaluated by a meta-reasoning judge for optimal answers
5. Auto-Orchestration — complex requests decomposed into DAG task graphs with dependency tracking and parallel execution
6. Dialectic User Modeling — three agents (Deriver, Dialectic, Dreamer) progressively understand user preferences and behavior

Self-hosted only. You must deploy on your own infrastructure — your own Replit account, your own server, your own Docker host. We do not provide hosting, shared instances, or managed deployments. Every fork runs independently with its own database, API keys, and configuration.

The platform works on any Node.js hosting:

• Replit: Create your own Replit account, import the repo, set secrets in the Secrets panel, hit Run
• Railway/Render: Connect your repo, set env vars, deploy
• Docker: docker-compose up -d — includes PostgreSQL with pgvector, ready out of the box
• VPS: Clone, npm install, set env vars, npm run dev
• Port: Serves frontend and backend on a single port (default: 5000)

git clone https://github.com/Huskyauto/VisionClaw-Agent-Public-Release.git
cd VisionClaw-Agent-Public-Release
cp .env.example .env   # edit with your API keys
docker-compose up -d    # or: npm install && npm run dev

VisionClaw Agent is an independent AI agent platform — not related to the Intent-Lab/VisionClaw project (a smart glasses AI assistant for Meta Ray-Ban). This repo is a standalone, self-hosted multi-tenant operations platform. It works with just an LLM provider and PostgreSQL — no external ecosystem required.

Areas under active development:

• Modularization — Breaking down large server files (routes, tools) into domain-specific modules for easier navigation and community contribution
• Type safety — Incremental migration from any types to strict TypeScript interfaces
• CI/CD — GitHub Actions pipeline for lint, typecheck, and automated testing
• Plugin architecture — Making it easier to add custom tools and agents without modifying core files
• API documentation — OpenAPI/Swagger spec for the 300+ endpoints

Community contributions welcome — see CONTRIBUTING.md.

VisionClaw Agent was originally built and hosted on Replit — a collaborative cloud development platform that makes it easy to build, deploy, and share full-stack applications. Replit's integrated environment, managed PostgreSQL, one-click deployments, and AI-assisted development made it possible to go from idea to production-ready platform without managing infrastructure. If you're looking for the fastest way to fork and run your own instance, Replit is a great place to start.

MIT License — free to fork, modify, and deploy for any purpose. See LICENSE.

Created by Robert Washburn | huskyauto@gmail.com