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

30 KiB

Raw Permalink Blame History

Waggle OS -- Technical Architecture Analysis

Date: 2026-04-08 Scope: Full codebase analysis of packages/core, packages/agent, packages/waggle-dance, packages/shared Purpose: Identify crown jewels, technical moat, differentiation, risks

Architecture Diagram

+----------------------------------------------------------------------+
|                          DESKTOP SHELL                                |
|  Tauri 2.0 (Rust)    React 18 + Vite + Tailwind + shadcn/ui         |
|  IPC allowlist        apps/web/ (desktop OS + dock UI)               |
+-------------------------------+--------------------------------------+
                                |
                         Tauri IPC
                                |
+-------------------------------v--------------------------------------+
|                      FASTIFY SIDECAR (Node.js)                       |
|  packages/server  --  REST API  --  Clerk JWT auth                   |
+---+------------+------------+------------------+---------------------+
    |            |            |                  |
    v            v            v                  v
+--------+ +----------+ +-----------+    +-------------+
| Agent  | |  Core    | | Shared    |    | Waggle      |
| Engine | |  Mind    | | Types +   |    | Dance       |
|        | |          | | Tiers     |    | Protocol    |
+---+----+ +----+-----+ +-----------+    +------+------+
    |           |                                |
    |           v                                |
    |    +------+-------+                        |
    |    | SQLite + FTS5 |                       |
    |    | + sqlite-vec  |                       |
    |    | (.mind files) |                       |
    |    +--------------+                        |
    |                                            |
    v                                            v
+---+--------------------------------------------+---+
|              LiteLLM Proxy (model-agnostic)        |
|  Anthropic | OpenAI | Ollama | LiteLLM gateway     |
+------------------------------------------------+---+
                                                 |
                                     +-----------v-----------+
                                     |     KVARK (Enterprise)|
                                     |  Sovereign AI platform|
                                     |  SharePoint/Jira/Slack|
                                     +-----------------------+

Data Flow

User Message
  |
  v
buildSystemPrompt() --> Identity + Self-Awareness + Preloaded Context
  |
  +-- recallMemory(query) --> HybridSearch (FTS5 keyword + sqlite-vec vector)
  |                              |
  |                              +--> RRF fusion + scoring (temporal/importance/graph)
  |
  v
runAgentLoop()
  |-- LiteLLM /chat/completions (streaming SSE)
  |-- Tool execution loop (max 10 turns)
  |     |-- scanForInjection() on every tool output
  |     |-- HookRegistry pre:/post: events
  |     |-- LoopGuard (duplicate call detection)
  |     |-- Governance policy enforcement
  |
  v
autoSaveFromExchange()
  |-- Pattern matching: preferences, decisions, corrections, research
  |-- CognifyPipeline: frame save + entity extraction + KG enrichment + vector index
  |
  v
Response to user (with recalled[] for UI badges)

1. Memory Architecture -- THE Crown Jewel

1.1 The MindDB

Each workspace and user gets a separate .mind SQLite database. The schema has 7 layers:

Layer	Table(s)	Purpose
0	`identity`	Single-row user profile (name, role, personality, system_prompt)
1	`awareness`	Active tasks, pending items, context flags (max 10, with expiry)
2	`memory_frames` + `memory_frames_fts` + `memory_frames_vec`	I/P/B frame memory with FTS5 keyword search and 1024-dim vector search
3	`knowledge_entities` + `knowledge_relations`	Entity-relation knowledge graph with temporal validity
4	`procedures`	GEPA-optimized prompt templates with success rate tracking
5	`improvement_signals`	Recurring behavioral patterns (capability gaps, corrections, workflow patterns)
6	`install_audit`	Capability install trust trail (proposed/approved/installed/rejected)

1.2 Frame Architecture (I/P/B Model)

Memory uses a video compression-inspired frame model:

I-Frame (Intra): Complete snapshot -- the baseline state of a memory topic. Self-contained.
P-Frame (Predictive): Delta from an I-frame -- captures changes, updates, corrections. References a base_frame_id.
B-Frame (Bidirectional): Cross-reference frame linking multiple other frames together. Stores references[] as JSON.

Frames are organized by GOP (Group of Pictures) mapped through sessions. Each session has a gop_id, and frames within it have a monotonically increasing t value. State reconstruction: take the latest I-frame for a GOP and apply all P-frames since.

Importance levels with multipliers: critical (2.0x), important (1.5x), normal (1.0x), temporary (0.7x), deprecated (0.3x).

Source provenance: Every frame tracks how it was created: user_stated, tool_verified, agent_inferred, import, system, personal, workspace.

Deduplication: SHA-256 content hashing on the last 500 frames prevents duplicate I-frames. Duplicates update access count instead.

1.3 Dual-Mind Architecture

The Orchestrator maintains two simultaneous memory stores:

Personal Mind: User preferences, communication style, corrections. Persists across ALL workspaces.
Workspace Mind: Project context, decisions, task progress, domain knowledge. Scoped to one workspace.

The setWorkspaceMind() method activates a workspace mind alongside the personal mind. Both are queried in parallel during recallMemory(). Personal preferences (detected by content prefix patterns like "User preference:", "Style note:", "Correction from user:") are always loaded regardless of active workspace.

Memory routing rules in autoSaveFromExchange():

Preferences, corrections, style notes --> personal mind
Decisions, research, work output --> workspace mind

1.4 HybridSearch -- Retrieval Engine

Search combines three signals using Reciprocal Rank Fusion (RRF):

FTS5 keyword search: Porter stemming + unicode61 tokenizer, with OR-based matching for better recall. Stop word filtering. Falls back to LIKE on FTS5 parse errors.
sqlite-vec vector search: 1024-dimensional embeddings via pluggable EmbeddingProvider. Supports InProcess (Xenova/MiniLM), Ollama (nomic-embed-text), Voyage, OpenAI, LiteLLM, with deterministic mock fallback.
Relevance scoring with 4 configurable profiles:
- Temporal: exponential decay with 30-day half-life, 7-day recency boost
- Popularity: logarithmic access count scaling
- Contextual: knowledge graph BFS distance (0/1/2/3 hops = 1.0/0.7/0.4/0.2)
- Importance: multiplied by the frame's importance level

Four scoring profiles weight these differently: balanced, recent, important, connected.

1.5 CognifyPipeline -- Memory Extraction

The cognify() method is the write-path pipeline:

Ensure a session exists (create one if needed)
Save frame (I-frame if first in GOP, P-frame otherwise)
Extract entities from content via regex-based NER (persons, organizations, technologies, projects, concepts, tools)
Upsert entities into KnowledgeGraph
Create co-occurrence relations between entities in the same text
Extract semantic relations (led_by, reports_to, depends_on, maintained_by, affiliated_with, approved) via pattern matching
Index the frame for vector search
Optionally find related frames via MemoryLinker

1.6 autoSaveFromExchange -- Passive Memory Accumulation

After every user/assistant exchange, the Orchestrator scans for save-worthy signals:

Preferences: 10 regex patterns ("I prefer...", "call me...", "from now on...", etc.)
Implicit style detection: 6 behavioral patterns (bullet preference, concise preference, code-first, etc.)
Decisions: 7 patterns ("let's go with...", "decided to...", "the plan is...", etc.)
Corrections: User disagreements saved as important frames
Research findings: Structured output with URLs saved with source attribution
Structured extraction (F29): Inline decisions, user questions, key bullet points, work output summaries

This is the mechanism by which Waggle "learns" without explicit save commands.

1.7 What Makes This Different from ChatGPT Memory / Claude Projects

Capability	Waggle OS	ChatGPT Memory	Claude Projects
Storage	Local SQLite per workspace	Cloud, opaque	Cloud, project-scoped files
Persistence	Permanent until deprecated	Session-scoped + background consolidation	Project file lifetime
Structure	I/P/B frames + knowledge graph	Flat facts	Flat documents
Search	Hybrid (keyword + vector + graph)	Unknown internal	Document-level retrieval
Dual scope	Personal + workspace minds	Single global	Per-project only
Entity extraction	Automatic with relations	No graph	No graph
Provenance	7 source types tracked	No provenance	File-level only
Importance levels	5 levels with scoring weights	Binary (remembered/not)	No importance
Conflict detection	CRITICAL protocol with user confirmation	Silent overwrite	No conflict handling
Data locality	User's machine, never leaves	OpenAI servers	Anthropic servers
Temporal scoring	Decay + recency boost	Unknown	No temporal weighting

The fundamental difference: Waggle treats memory as a structured, queryable knowledge base with graph relations and temporal scoring. Competitors treat it as a flat fact store or document repository. The I/P/B frame model enables state reconstruction (like git), not just retrieval.

2. Agent Orchestration

2.1 The Agent Loop

runAgentLoop() is a clean, well-structured ReAct loop:

LiteLLM-proxied chat completions (model-agnostic via OpenAI-compatible API)
SSE streaming with tool call accumulation
Rate limit handling: exponential backoff with retry cap (3 retries for 429, 502, 503, 504)
Token budget enforcement (graceful termination when exceeded)
AbortSignal support for client disconnection
Injection scanning on every tool output via scanForInjection()
Loop guard preventing identical tool calls from cycling
Plugin tool merging at runtime
Team governance policy enforcement (blocked tools list)
Pre/post hook system (10 event types) for extensibility

2.2 System Prompt Construction

buildSystemPrompt() assembles 3 sections with section caching:

Identity (cached -- only recomputes when identity changes): User profile from IdentityLayer
Self-Awareness (uncached -- changes every call): Tool inventory, memory stats, improvement signals, skills list
Preloaded Context (uncached): Recent memories (importance-sorted), active awareness items, top knowledge entities, personal preferences

2.3 Behavioral Specification v3.0

Split into 5 named sections totaling approximately 290 lines of rules:

coreLoop: 5-step thinking process (RECALL --> ASSESS --> ACT --> LEARN --> RESPOND) with CRITICAL memory conflict protocol
qualityRules: Anti-hallucination discipline, structured output, context grounding, professional disclaimers
behavioralRules: Memory-first, tool intelligence, narration heuristics, error recovery, planning
workPatterns: Drafting from context, decision compression, research in context
intelligenceDefaults: Tool catalog, capability acquisition, sub-agent delegation, workflow composition

2.4 Sub-Agent Orchestrator

SubagentOrchestrator implements a supervisor/worker pattern:

Dependency-ordered execution with topological sorting
Context injection between steps (step B can access step A's results)
Result aggregation with 3 modes: concatenate, last, synthesize (the synthesize mode spawns a synthesizer sub-agent)
EventEmitter-based status tracking for UI updates
7 role presets with predefined tool sets (researcher, writer, coder, analyst, reviewer, planner, synthesizer)
Circular dependency detection (breaks loops with error state)

2.5 Workflow Composer

Implements lightest sufficient execution mode selection:

direct -- Agent handles directly
structured_single_agent -- Agent follows a plan, no sub-agents
skill_guided -- Agent uses a loaded skill's workflow
subagent_workflow -- Full multi-agent orchestration

The composer analyzes task shape (type, phases) and picks the lightest mode that works. This prevents unnecessary sub-agent spawning for simple tasks.

2.6 Waggle Dance Protocol

Inter-agent communication protocol with typed messages:

Request types: knowledge_check, task_delegation, skill_request, model_recommendation
Response types: knowledge_match, task_claim
Broadcast types: discovery, routed_share, skill_share, model_recipe

The WaggleDanceDispatcher routes messages to real handlers (memory search, worker spawning, skill installation, capability resolution).

3. Tool Intelligence

3.1 Dynamic Tool Filtering

Three filtering mechanisms:

Context-based: Code tools vs research tools vs general (predefined sets)
Availability-based: Runtime checkAvailability() on each tool
Offline-capable: Tools tagged with offlineCapable for disconnected operation
Config-based: Explicit enabled_tools / disabled_tools lists

3.2 Capability Router

When a tool is not found, CapabilityRouter resolves alternatives by searching across 6 sources:

Native tools (exact and partial match)
Installed skills (keyword matching in content)
Plugins (manifest matching)
MCP servers (name matching, health-aware)
Sub-agent roles (keyword mapping)
Connectors (service/action matching)

Falls back to a "missing" route with an install suggestion.

3.3 Context Compression

5-step pipeline for long conversations:

Detect: Estimate tokens (4 chars/token heuristic), check against threshold (default: 50% of 128K)
Prune: Replace old tool results with "[Cleared]" placeholders (free, no LLM)
Protect: Split into head (system + first N messages), tail (recent messages), middle (compressible)
Summarize: Call budget model on the middle using COMPACTION_PROMPT
Inject: Replace middle with summary message

Iterative: previous summaries are fed back for cumulative compression.

3.4 Credential Pool

Round-robin API key rotation with policy-based cooldowns:

429 (rate limit) --> 1 hour cooldown, auto-recovers
402 (payment required) --> 24 hour cooldown, auto-recovers
401 (unauthorized) --> permanently disabled
Other errors --> 5 minute cooldown

Vault convention: provider, provider-2, provider-3, etc. Supports multiple keys per LLM provider for throughput maximization.

3.5 Injection Scanner

Three pattern categories with weighted scoring:

Role override patterns (0.5 weight): "ignore previous instructions", "you are now", multi-language variants, memory wipe attempts
Prompt extraction patterns (0.4 weight): "show your system prompt", "reveal your instructions"
Instruction injection patterns (0.3/0.6 weight): "IMPORTANT: ignore", "[INST]", "<>", fake authority claims

Tool outputs are scored higher (0.6) for instruction injection because they are more dangerous attack vectors. Threshold at 0.3 -- anything above is flagged.

3.6 Cost Tracker

Per-model pricing table with usage accumulation. Tracks input/output tokens per call with workspace-level cost attribution. Supports real-time daily totals and per-model breakdowns.

3.7 Improvement Detector

Three signal categories tracked in improvement_signals table:

Capability gaps: When tools are missing, the gap is recorded. After repeated occurrences, it surfaces as an actionable suggestion.
Corrections: User corrections are detected and tracked to prevent repeated mistakes.
Workflow patterns: Recurring multi-step patterns that could benefit from templates.

Signals are surfaced once via the self-awareness system prompt and then marked as surfaced to avoid repetition.

4. Skill and Plugin System

4.1 Skills

Markdown files with optional YAML frontmatter:

---
name: Deploy Helper
description: Helps deploy applications
permissions:
  codeExecution: true
  network: true
---

Skills are parsed by parseSkillFrontmatter() and loaded into the agent's context. They can be:

Built-in (shipped with Waggle)
User-created via the create_skill tool
Shared between agents via Waggle Dance skill_share messages
Discovered and installed via acquire_capability / install_capability

4.2 Hooks

10 lifecycle events with registry pattern:

pre:tool / post:tool -- Before/after any tool execution
session:start / session:end -- Session lifecycle
pre:response / post:response -- Response generation
pre:memory-write / post:memory-write -- Memory mutations (can cancel writes)
workflow:start / workflow:end -- Workflow lifecycle

Hooks can be scoped to specific workspaces. Pre-hooks can cancel execution. Activity log maintained (last 50 events).

4.3 Install Audit Trail

Every capability installation is recorded:

Timestamp, capability name, type (native/skill/plugin/mcp), source
Risk level (low/medium/high)
Trust source, approval class (standard/elevated/critical)
Action (proposed/approved/installed/rejected/failed)
Initiator (agent/user/system)

5. KVARK Integration

4 enterprise tools gated to Business/Enterprise tiers:

kvark_search -- Full-text search across enterprise sources (SharePoint, Jira, Slack)
kvark_ask_document -- Focused Q&A on a specific enterprise document
kvark_feedback -- Relevance feedback loop for retrieval quality improvement
kvark_action -- Governed enterprise actions (create Jira ticket, post Slack message) with audit trail

Combined Retrieval merges workspace memory, personal memory, and KVARK results:

KVARK is only queried when local results are insufficient (< 3 results with score >= 0.7)
Conflict detection between workspace memory and KVARK results using polarity analysis (positive vs negative status keywords)
Every result carries explicit source attribution

6. Technology Decisions

Why Tauri (not Electron)

Binary size: Tauri 2.0 binaries are 5-15 MB vs Electron's 150+ MB (uses system WebView)
Memory footprint: Significantly lower -- critical for a desktop AI app that already needs memory for embeddings and SQLite
Security: Explicit IPC allowlist in tauri.conf.json (no "allow all" wildcard). Rust shell provides memory safety.
Cross-platform: Windows + macOS from single codebase with Rust's cross-compilation

Why SQLite + sqlite-vec (not Postgres + pgvector)

Desktop-first: No database server to install. The .mind file IS the database. Zero config.
Portability: Copy the file, move it between machines. Backup is a file copy.
Performance: WAL mode for concurrent reads, FTS5 is compiled into SQLite. sqlite-vec provides HNSW-like approximate nearest neighbor search.
Privacy: Data never leaves the user's machine. No connection string, no cloud database.
Cost: Zero infrastructure cost. Perfect for a free-tier product.

Why Fastify (not Express)

Performance: Fastify is 2-5x faster than Express for JSON serialization, which matters for the streaming agent loop.
Schema validation: Built-in JSON schema validation on routes.
Plugin system: Clean plugin architecture for modular route registration.

LiteLLM -- Model Agnostic Design

Single proxy endpoint: Agent loop talks to one URL regardless of model provider.
Key rotation: Combined with CredentialPool for multi-key management.
Model switching: Users can change models without code changes. Personas declare modelPreference but users override.
Offline capability: When LiteLLM is unavailable, offline-capable tools still work.

7. Technical Moat Assessment

Strong Moats (Hard to Replicate)

Component	Moat Strength	Why
I/P/B Frame Model	High	Novel application of video compression concepts to memory. The frame-based state reconstruction with GOPs is architecturally unique. No competitor does this.
Dual-Mind Architecture	High	Personal + workspace memory with automatic routing is a system design insight. Requires deep thinking about scoping that simple RAG does not address.
autoSaveFromExchange	Medium-High	30+ regex patterns for passive memory accumulation. The pattern library represents significant behavioral tuning that requires real user testing to calibrate.
HybridSearch with RRF	Medium	RRF fusion of keyword + vector + graph signals is well-known in IR research but uncommon in desktop AI. The 4 scoring profiles are a usability advantage.
CognifyPipeline	Medium	End-to-end write path from text to frames + entities + relations + vectors. Straightforward but well-integrated.
Behavioral Spec v3.0	Medium	290 lines of carefully tuned agent rules. The memory conflict protocol is a genuine innovation -- no other agent platform prevents memory drift this way.
Context Compression	Medium	5-step pipeline with iterative summaries. The head/middle/tail splitting with budget model summarization is clever.
Improvement Signals	Medium	Self-correcting agent behavior via recurring pattern detection. Novel concept for consumer AI.

Weak Moats (Easily Replicated)

Component	Moat Strength	Why
Injection Scanner	Low	20 regex patterns. Any team can build equivalent in a day.
Cost Tracker	Low	Simple pricing table + usage accumulation.
Credential Pool	Low	Standard round-robin with cooldowns.
Tool Filtering	Low	Predefined tool sets by context.
Entity Extractor	Low	Regex-based NER without ML. Accuracy is limited compared to spaCy or LLM-based extraction.

Compound Moat

The real moat is not any single component but the integration of all of them into a coherent memory-first agent platform. The combination of I/P/B frames + dual-mind + hybrid search + auto-save + behavioral spec + improvement signals creates a system where the agent genuinely gets better over time in a way that is structurally different from competitors.

8. Technical Debt and Risks

High Priority

Entity extraction is regex-only. The extractEntities() function uses pattern matching with a hardcoded list of tech terms and proper noun heuristics. This will miss domain-specific entities and produce false positives. An LLM-based or spaCy-based extraction step would dramatically improve KnowledgeGraph quality.
Knowledge graph queries are O(n) scans. getEntitiesByType('') fetches ALL entities, then filters in JavaScript. For large knowledge bases, this will degrade. The graph needs indexed queries and possibly a proper graph traversal engine.
No vector index maintenance. sqlite-vec does not have automatic index rebuilding. As frames are deleted or updated, orphan vectors accumulate. No vacuum or reindexing mechanism exists.
Token estimation is 4-chars-per-token heuristic. The context compressor uses this approximation. For non-English text or code-heavy conversations, this can be off by 30-50%, causing premature or late compression.
No memory compaction/consolidation. Frames accumulate indefinitely. There is no mechanism to merge old P-frames into new I-frames, or to prune deprecated frames. Over months of use, the .mind file will grow unboundedly.

Medium Priority

Scoring profiles are static. The 4 scoring profiles have hardcoded weights. There is no adaptive scoring that learns which profile works best for a given user or workspace.
Conflict detection is keyword-based. The detectConflict() function uses simple polarity word lists. It will miss semantic conflicts and produce false positives on keyword collisions.
No embedding dimension migration. If the embedding model changes (different dimension count), existing vectors in memory_frames_vec become incompatible. No migration path exists.
Stripe integration is incomplete. The tier system is defined but stripePriceId values come from environment variables. No billing webhook handling visible in the codebase.
Waggle Dance protocol is partially implemented. The dispatcher handles 4 of 8 message subtypes. model_recommendation, knowledge_match, task_claim, and discovery are defined but not dispatched.

Low Priority

No rate limiting on sidecar API routes. The Fastify server exposes endpoints without throttling.
Improvement signals are never pruned. The improvement_signals table grows indefinitely with no archival.

9. Comparison to Competitors

vs. ChatGPT (OpenAI)

Dimension	Waggle OS	ChatGPT
Memory model	Structured frames with I/P/B + knowledge graph	Flat fact store, opaque consolidation
Data location	Local (user's machine)	OpenAI cloud
Search	Hybrid (keyword + vector + graph)	Unknown internal
Multi-workspace	Dual-mind (personal + workspace)	Single global memory
Tool extensibility	Skills + plugins + MCP + connectors	GPT Actions (HTTP endpoints)
Enterprise bridge	KVARK integration with governed actions	No self-hosted option
Cost visibility	Per-model tracking with daily totals	Hidden in subscription
Offline	Partial (offline-capable tools)	None

Waggle advantage: Memory depth, data sovereignty, enterprise bridge ChatGPT advantage: Scale, model quality (GPT-4 family), ecosystem (millions of GPTs)

vs. Claude Projects (Anthropic)

Dimension	Waggle OS	Claude Projects
Memory model	I/P/B frames + auto-save from conversations	Static files uploaded to project
Persistence	Permanent, cross-session, auto-enriched	File lifetime only
Context	Automatic memory recall per query	Full project files in context window
Desktop	Native Tauri app	Web-only
Agent tools	30+ tools with plugin system	Limited tool use
Multi-agent	SubagentOrchestrator with dependency DAG	No multi-agent
Enterprise	KVARK with governed actions	No enterprise bridge

Waggle advantage: Automatic memory, desktop, multi-agent, enterprise Claude advantage: Model quality (Claude 4), massive context window (1M tokens), simpler UX

vs. Cursor / Windsurf / Cline (AI Code Editors)

Dimension	Waggle OS	AI Code Editors
Scope	General-purpose workspace AI	Code-focused
Memory	Persistent knowledge graph	Code index only
Personas	22 domain-specific roles	Single coding persona
Document output	DOCX generation, reports, briefs	Code output only
Enterprise	KVARK + governed actions	GitHub/GitLab integration

Waggle advantage: Breadth (not just code), persistent memory, enterprise Code editor advantage: Deeper code understanding, LSP integration, inline editing

vs. Notion AI / Mem.ai

Dimension	Waggle OS	Notion AI / Mem.ai
Agent capability	Full ReAct loop with tools	Q&A over documents
Memory	Auto-extracted structured frames	Document-level
Privacy	Local-only SQLite	Cloud
Multi-agent	Yes	No
Extensibility	Skills + plugins + MCP	Limited

Waggle advantage: True agent with tools, local data, extensibility Notion/Mem advantage: Better collaborative editing, richer document UX

10. Summary of Crown Jewels

Tier 1 -- Genuinely Innovative

I/P/B Frame Model with GOP Sessions -- Novel application of video compression to AI memory. Enables state reconstruction, importance-weighted retrieval, and provenance tracking in a way no competitor does.
Dual-Mind Architecture -- Separating personal identity/preferences from workspace knowledge, with automatic routing, is a system design insight that solves a real problem (cross-project preference continuity).
Memory Conflict Protocol -- The CRITICAL block in the behavioral spec that prevents memory drift through contradiction detection and user confirmation is a safety innovation absent from all competitors.
autoSaveFromExchange -- Passive memory accumulation from every conversation turn, with 30+ calibrated patterns for preferences, decisions, corrections, and research findings. This is what makes the memory system feel "alive."

Tier 2 -- Well-Engineered Differentiators

HybridSearch with Multi-Signal Scoring -- RRF fusion of keyword + vector + knowledge graph with 4 configurable profiles and temporal decay. Solid IR engineering.
Context Compression Pipeline -- 5-step iterative compression that preserves critical information while managing context window limits. The head/middle/tail split with budget model summarization is well-designed.
KVARK Combined Retrieval with Conflict Detection -- Merging local memory with enterprise knowledge, only querying KVARK when local results are insufficient, with polarity-based conflict detection.
Improvement Signal System -- Self-correcting agent behavior through recurring pattern detection. The agent learns from its own failures.

Tier 3 -- Solid Infrastructure

Tier-Gated Capabilities -- Clean tier architecture (SOLO/BASIC/TEAMS/ENTERPRISE) with per-capability enforcement including embedding quotas.
CredentialPool with Policy-Based Cooldowns -- Production-grade key rotation for multi-provider LLM access.
Hook System -- 10-event lifecycle with workspace scoping and cancellation support. Enables governance and extensibility.
Waggle Dance Protocol -- Inter-agent communication with typed messages for team collaboration.

End of analysis.

30 KiB Raw Permalink Blame History