oleg.m/waggle-os

Fork 0

Files

Oleg Maslov 0c3e2ead3b

Installer Smoke / installer-smoke (push) Has been cancelled

Details

moving

2026-09-02 10:10:29 +02:00

16 KiB

Raw Blame History

Waggle OS -- Product Intelligence Document

Date: April 2026 Classification: Internal -- Egzakta Group Prepared by: Automated 4-agent deep analysis (feature audit, architecture analysis, UX analysis, competitive intelligence)

Executive Summary

Waggle OS is a desktop-native AI agent platform with structured persistent memory -- a category that barely existed 12 months ago and is now emerging as the next frontier of AI tooling. After a deep audit of the entire codebase (50+ source files, 52 route endpoints, 80+ agent tools) and competitive analysis against 15 products, the assessment is:

Waggle is a genuinely differentiated product with a compound technical moat, but faces critical go-to-market challenges.

The memory system (5-layer architecture: FrameStore + HybridSearch + KnowledgeGraph + IdentityLayer + AwarenessLayer) is the most sophisticated persistent memory implementation in any shipping AI product. No competitor -- not Claude.ai, not ChatGPT, not Cursor, not Dust -- has anything approaching this depth. This is real, built, working infrastructure, not vapor.

However, Waggle's integration ecosystem is thin (28 connectors vs. Claude.ai's 6,000+ MCP connections), community presence is zero (vs. OpenClaw's 345K GitHub stars), and pricing is high ($79/seat Teams vs. $25-30/seat for Claude Team/ChatGPT Business). The product is a Ferrari engine in a car that most people don't know exists.

I. Product State -- What Waggle OS Actually Is

The Numbers

Dimension	Count	Status
Agent tools	80+	Built
Agent personas	22	Built with behavioral specs
API route files	52	Built
Built-in connectors	28	Built
Workflow templates	5	Built
LLM providers supported	12+	Built
Billing tiers	4 (Solo/Basic/Teams/Enterprise)	Defined, Stripe partial
Test suite	2,000+ tests	Passing
TypeScript errors	0	Clean across all packages

Architecture

+----------------------------------------------------------------------+
|                          DESKTOP SHELL                                |
|  Tauri 2.0 (Rust)    React 18 + Vite + Tailwind + shadcn/ui         |
+-------------------------------+--------------------------------------+
                                |  Tauri IPC
+-------------------------------v--------------------------------------+
|                      FASTIFY SIDECAR (Node.js)                       |
|  52 route files -- REST API -- Clerk JWT auth                        |
+---+------------+------------+------------------+---------------------+
    |            |            |                  |
    v            v            v                  v
+--------+ +----------+ +-----------+    +-------------+
| Agent  | |  Core    | | Shared    |    | Waggle      |
| Engine | |  Mind    | | Types +   |    | Dance       |
| 80+    | | 7-layer  | | Tiers     |    | Protocol    |
| tools  | | SQLite   | |           |    | (multi-     |
| 22     | | + vec    | |           |    |  agent)     |
| persona| | + KG     | |           |    |             |
+--------+ +----------+ +-----------+    +-------------+
                |
    +-----------v-----------+
    |  LiteLLM (12+ models) |---> KVARK Enterprise
    +------------------------+

Tier System

Feature	Solo (Free)	Basic ($15/mo)	Teams ($79/seat)	Enterprise
Workspaces	5	Unlimited	Unlimited	Unlimited
Personas	8 universal	All 22	All 22 + custom	Custom
Sub-agents	--	10 sessions	25 sessions	100
Connectors	5	All 28	All + team	All + KVARK
MCP servers	2	10	25	Unlimited
Skills	Community	Custom	Team library	Enterprise
Memory	Personal only	+ Workspace	+ Team sync	+ KVARK
Embeddings	In-process	+ Ollama/API	+ LiteLLM	Full

II. Crown Jewels -- What Makes Waggle Unique

Crown Jewel #1: Five-Layer Persistent Memory

This is Waggle's primary moat. The memory system has no equivalent in any competing product.

Layer	What It Does	Why It Matters
FrameStore	Video-compression-inspired I/P/B frame model with importance weighting, source provenance, and temporal decay	Memories aren't just stored -- they evolve, link, and self-organize
HybridSearch	Reciprocal Rank Fusion combining keyword (FTS5) + vector (sqlite-vec) + graph connectivity	Retrieval quality far exceeds single-method search
KnowledgeGraph	Entity-relation graph with typed ontology, co-occurrence detection, temporal validity	The agent builds a structured understanding of the user's world
IdentityLayer	Persistent user profile (name, role, personality, preferences, writing style)	The agent adapts to you, not the other way around
AwarenessLayer	Active task tracking, context flags, priorities, expiration	The agent knows what it's working on and what matters now

Competitor comparison:

ChatGPT Memory: Flat fact list. "User likes dark mode." No structure, no search, no graph.
Claude.ai Projects: Uploaded knowledge files + conversation context. Better than ChatGPT but no semantic search.
Cursor/Windsurf: Code-specific project memory. No knowledge graph, no identity layer.
Hermes Agent: Three-tier memory (working/episodic/semantic). Closest competitor, but no knowledge graph or identity layer.

Assessment: Waggle's memory is 2-3 generations ahead of ChatGPT/Claude and 1 generation ahead of Hermes.

Crown Jewel #2: Dual-Mind Architecture with Auto-Save

The autoSaveFromExchange system in the orchestrator uses 30+ calibrated regex patterns to passively extract and store:

User preferences and style
Decisions and corrections
Research findings with sources
Implicit constraints and deadlines
Relationship and organizational context

This means the agent gets smarter with every conversation without the user doing anything. Combined with the dual-mind routing (personal memories persist across all workspaces; workspace memories stay isolated), this creates a compounding knowledge advantage.

No competitor has this. ChatGPT's memory requires explicit "remember this" instructions. Claude.ai relies on project uploads. Waggle learns silently.

Crown Jewel #3: 22 Behavioral Personas with Guardrails

Each persona is not just a system prompt -- it includes:

Tool allowlist/denylist (enforced, not suggested)
Failure patterns (3+ documented per persona for self-correction)
Hard boundaries (wontDo statements)
Read-only mode for planner/verifier (no write tools, ever)
Suggested skills, connectors, and MCP servers

This means a Legal persona won't accidentally run bash commands, and a Planner can't modify files. The behavioral spec includes a memory conflict protocol (=== CRITICAL ===) that prevents the agent from silently overwriting contradictory memories.

Crown Jewel #4: Desktop-Native + Local-First

Tauri 2.0 (not Electron) means:

~10MB binary vs Electron's ~150MB
Native performance with Rust backend
Local SQLite -- data never leaves the machine unless explicitly synced
Offline-capable -- in-process embeddings, local memory, local LLM via Ollama
Privacy by architecture -- not a cloud feature bolt-on

Crown Jewel #5: Multi-Agent Orchestration for Non-Coding Domains

Most multi-agent systems (CrewAI, AutoGPT) focus on coding. Waggle's 5 workflow templates span:

research-team: Researcher -> Synthesizer -> Reviewer
review-pair: Writer -> Reviewer -> Reviser
plan-execute: Planner -> Executor -> Summarizer
ticket-resolve: Triage -> Investigator -> Responder
content-pipeline: Researcher -> Drafter -> Editor

Combined with the persona system, this enables multi-agent workflows for lawyers, consultants, marketers, HR, and finance -- markets that coding-focused tools ignore entirely.

III. UX Assessment

Strengths

Committed OS metaphor -- Boot screen, dock, draggable/resizable windows, snap zones, status bar. Feels like a product, not a chat wrapper.
Progressive disclosure via tier-gated dock -- Solo sees 5 apps, Power users see the full suite. Prevents overwhelm.
WorkspaceBriefing -- When you open a workspace, you get a contextual greeting with remembered context, active tasks, and suggested prompts. This is a killer feature for returning users.
Global Search / Command Palette -- Ctrl+K fuzzy search across workspaces, settings, commands.
Two-step onboarding -- Template (what) + Persona (how) = clear mental model.
3-lane model fallback -- Primary/Fallback/Budget model chain with automatic switching.

Weaknesses

Boot screen has no skip -- 4.8 seconds for returning users is too long.
Very small text -- 9-10px throughout, accessibility risk.
Desktop-only -- No responsive design, no mobile, no tablet.
Knowledge graph visualization is primitive -- Static circular SVG, no interactivity.
Window controls are visually indistinct -- Three similar circles vs. macOS red/yellow/green.
Several monolithic UI components -- FilesApp (1,176 LOC), OnboardingWizard (1,028 LOC).

Design System (Hive DS)

The honey/amber/dark theme is distinctive and memorable:

Primary: #e5a000 (honey gold)
Background: #08090c (near-black)
Accent: #a78bfa (purple)
The bee avatars for personas are charming and on-brand.

IV. Competitive Positioning

Feature Comparison Matrix

Capability	Waggle	Claude.ai	ChatGPT	Cursor	Dust	Hermes
Persistent memory	*****	**	*	*	**	****
Knowledge graph	*****	--	--	--	--	--
Workspace isolation	*****	***	--	**	****	**
Multi-agent orchestration	****	--	--	**	***	***
Persona system	*****	--	*	--	--	**
Desktop-native	*****	--	--	*****	--	--
Integration ecosystem	**	*****	****	***	****	**
Coding capabilities	***	****	***	*****	--	**
Market presence	*	*****	*****	*****	***	**
Pricing competitiveness	**	****	****	****	***	*****

Where Waggle Wins

Memory depth -- No contest. 5-layer structured memory vs. flat fact lists.
Privacy/local-first -- Data stays on machine. Competitors are cloud-only.
Persona specialization -- 22 domain-specific agents with enforced tool boundaries.
Non-coding knowledge work -- Legal, finance, HR, consulting, marketing workflows.
Compounding intelligence -- Gets smarter with every session via auto-save.

Where Waggle Loses

Integration ecosystem -- 28 connectors vs. 6,000+ MCP connections on Claude.ai.
Community/awareness -- Zero open-source presence vs. 345K stars (OpenClaw) or 45K (CrewAI).
Pricing -- $79/seat Teams is 2-3x more than Claude Team ($25-30) or ChatGPT Business ($25).
Coding depth -- Cursor/Claude Code/Windsurf are far ahead for pure development workflows.
Mobile/web access -- Desktop-only limits reach. Claude.ai and ChatGPT work everywhere.
Stripe/billing -- Not yet live. Can't actually charge users.

Most Dangerous Competitors

Claude.ai -- If Anthropic expands its Projects + Memory + MCP into workspace-scoped persistent intelligence, it would directly threaten Waggle's core proposition with vastly more distribution.
Hermes Agent -- Open-source, three-tier memory, self-improving skills, $10-20/mo total cost. The closest architectural match to Waggle at a fraction of the price.
Dust.tt -- Team AI platform with strong integrations. If Dust adds structured memory, it becomes a direct competitor for enterprise.

V. Is Waggle Valuable?

Yes, unambiguously.

The core product solves a real, painful problem: AI assistants forget everything. Every conversation starts from zero. Every project loses context. Knowledge workers waste enormous time re-explaining their world to AI tools.

Waggle is the only product where:

The AI knows your projects (workspace memory)
The AI knows you (identity layer + auto-save)
The AI builds knowledge over time (knowledge graph + memory weaver)
The AI specializes to your domain (22 personas)
Your data never leaves your machine (local-first SQLite)

The product-market fit signal

The product is built. Not "we have a landing page and a waitlist." The codebase contains:

80+ working agent tools
2,000+ passing tests
52 API route files
A full desktop OS with windows, dock, onboarding, and settings
Memory system with vector search, knowledge graph, and auto-consolidation

This is real product at a level of completeness that most Series A startups don't achieve.

Comparable to Claude Code?

No, and it shouldn't try to be. Claude Code is a coding-focused terminal tool. Waggle is a workspace-native agent platform. They overlap on coding tasks (Waggle has a coder persona), but Waggle's value is in knowledge work -- research, writing, analysis, planning, legal review, financial modeling. Claude Code is a power drill; Waggle is a workshop.

Comparable to ChatGPT?

Waggle is what ChatGPT should have become. ChatGPT has massive distribution but shallow memory, no workspace concept, no persona system, and no multi-agent orchestration. Waggle has all of these. The question is whether Waggle can capture even 0.1% of ChatGPT's user base -- which would be enormous.

VI. Strategic Recommendations

P0 -- Must Do (blocks revenue)

Ship Stripe billing -- The tier system is defined, the UI exists, but you can't charge money. This is the #1 blocker.
Expand MCP connectors to 50+ -- The integration gap vs. Claude.ai is the biggest competitive vulnerability. Focus on the top-20 work tools: Google Workspace, Slack, Notion, Jira, Linear, GitHub, Salesforce, HubSpot.
Skip-boot for returning users -- 4.8s boot screen will kill retention. Add localStorage flag.

P1 -- Should Do (accelerates growth)

Open-source the core memory system -- The FrameStore + HybridSearch + KnowledgeGraph could be the "React of AI memory." Open-sourcing it builds community, credibility, and ecosystem.
Web app version -- Desktop-only limits TAM. A web version (even feature-reduced) dramatically expands reach.
Self-improving memory -- Hermes has this. Memory Weaver consolidation exists but needs auto-skill extraction from patterns.
Reduce Teams pricing -- $79/seat to $39-49/seat. Still premium, but competitive.

P2 -- Could Do (market expansion)

Mobile companion app -- Read-only access to workspace memories + quick chat.
Visual workflow builder -- Drag-and-drop multi-agent workflow creation.
Claude Code as a backend -- Instead of competing with Claude Code on coding, integrate it as the coder persona's engine.

VII. Bottom Line

Waggle OS is a technically impressive, genuinely differentiated product that is pre-revenue and under-distributed. The memory system is the most sophisticated in any shipping AI product. The persona system solves real workflow problems for knowledge workers. The desktop-native, local-first architecture is a genuine privacy advantage.

The product is not comparable to Claude Code (different category), not comparable to Cursor (different market), but directly competitive with Claude.ai + ChatGPT for knowledge workers and ahead of both on memory and workspace intelligence.

The biggest risks are:

Revenue -- Stripe isn't live. Can't charge users.
Distribution -- Nobody knows Waggle exists.
Velocity -- Claude.ai could ship workspace memory + persona switching tomorrow and own the market with their distribution advantage.

The biggest opportunity is: Being the "Local-first, privacy-native, memory-first AI workspace" before the cloud giants figure out that memory is the next platform.

This document was generated by a 4-agent parallel analysis: feature audit (80+ tools catalogued), architecture deep-dive (crown jewels identified), UX analysis (17 views + 10 overlays reviewed), and competitive intelligence (15 competitors profiled). Source data in docs/product-analysis/.

16 KiB Raw Blame History