waggle-os/docs/analysis/openhuman-adoption-2026-06-28.md

OpenHuman → Waggle OS: Prioritized Adoption Report (Hardened, Final)

1. Framing & Honest Verdict

OpenHuman is a genuine mature peer — Rust core, real memory substrate, shipped voice/meet/screen surfaces. So the question is not "is it serious," it's the founder's bar: does any item move a Waggle-specific lever — KVARK funnel, the memory+harvest moat, the skills/connectors upgrade trigger, or Waggle-funded proxy cost — or is it the same "nice but not differentiating" class the founder just rejected wholesale (Local-Agent-Studio)?

Where OpenHuman is genuinely ahead (verified against grounding):

• Pre-LLM per-tool-result compression (TokenJuice). Confirmed gap: tool output is appended to the messages array verbatim (agent-loop.ts:511 r.content; tool-executor.ts:161-166 raw result returned, no compaction). Waggle only compresses after the conversation crosses 50% (context-compressor.ts).
• Capability-aware model routing. Confirmed: resolveUsableModel (model-availability.ts:86-109) is provider-readiness fallback only; capability-router.ts routes tool names to sources, not tasks to model classes. No "lightweight → cheap, reasoning → frontier" policy exists.
• Scheduled auto-fetch connector→memory loop. The grounding flags this as "the ONLY significant gap in the memory substrate" — cron infra (cron-store.ts) and harvest (harvest/pipeline.ts, pull-only) both exist but are never wired together.
• Idle background cognition (Subconscious), trigger triage, memory-diff — real, but each carries a real-cost or prerequisite problem (below).

Where Waggle already matches or leads (do not touch):

• Memory substrate — hierarchical trees (wiki-compiler), Obsidian/Notion export, 4-profile RRF + reranker + chunk-level scoring (search.ts/scoring.ts), KG bridge. This is the LoCoMo-87.66-SOTA moat; at-parity-or-ahead on every memory item.
• Approval gate (confirmation.ts — risk taxonomy + autonomy tiers + never-autopass blacklist) — more sophisticated than OpenHuman's.
• Warm-start memory (orchestrator.recallMemory, Hermes session-start), cron/automations, iteration-budget, loop-guard, awareness, Composio + 30 connectors, vault, Hive DS — all present.

Does anything clear the bar? Yes — three items, heavily scope-cut, not the draft's three:

1. A pure-code tool-result compression subset (JSON-table crusher + live search dedup) — a clean, zero-added-cost margin lever that reuses dedup.ts.
2. Deterministic capability-aware routing of known-lightweight internal calls to Haiku-on-proxy / local — a real proxy-cost lever that works even for a vanilla FREE user with no Ollama.
3. PRO-gated auto-fetch connector→memory — the only item that touches the actual memory+harvest moat rather than just margin; the grounding calls it the sole substrate gap; gating to PRO makes it simultaneously a tier trigger and cost-safe.

What I cut from the draft as still-too-loose: the token-aware-truncation LLM-summarization fallback (largely redundant with existing message-level compression, and summarizing-on-truncation can add budget-model proxy cost on the very FREE/TRIAL tier it claims to protect — a hard slice is free); the standalone "savings metering" ADOPT (an internal cost-tracker accumulator is fine; a user-facing "we saved you N tokens" panel is exactly the nice-but-not-differentiating scope creep the founder rejects); and the routing layer's arbitrary-user-task complexity classifier (needs its own classifier = cost + risk; the deterministic internal-call subset captures most of the win with none of it).

Honest bottom line: two tightly-scoped cost levers + one PRO-gated moat-deepener, with metering folded in as internal telemetry. Defer four real-but-blocked items behind explicit triggers; skip the rest. Resist the Rust engine, the 96-rule overlay, the ML compressor, the mascot, the Meet agent.

---

2. Adoption Matrix

Capability (OpenHuman)	Waggle status	Verdict	Impact	Effort	Strategic fit
Per-result: JSON-table crusher (pure code)	none (verbatim)	ADAPT	M–H*	S	cost lever
Per-result: live search-result dedup/merge	partial (ingest-only)	ADAPT	M	S	cost lever
Per-result: token-aware truncation (no LLM)	partial (char-only)	ADAPT (minor)	L–M	S	cost lever
Per-result: LLM-summarization-on-truncation fallback	partial (msg-level only)	DROP→DEFER	L	M	redundant + can add cost
Content-aware kind classifier (deterministic, feeds crusher)	none	ADAPT	—	S	cost lever (input only)
Capability-aware routing — known-lightweight internal calls → Haiku/local	partial (readiness-only)	ADAPT	H	M	cost lever
Capability-aware routing — arbitrary user-task complexity	partial	DROP	M	M	speculative (classifier cost)
Privacy-required-on-device flag	none	ADAPT (bundle w/ routing)	L	S	KVARK narrative
Savings tracking / cost attribution	none	ADOPT (internal only)	L	S	instrumentation
Auto-fetch connector→memory loop (PRO-gated, dedup-capped)	partial (cron infra, no job type)	ADOPT	M–H	M	moat + tier trigger
Trigger triage pipeline (drop/ack/react/escalate)	missing (event triggers deferred C24)	DEFER	H	L	blocked on webhook infra
Subconscious idle cognition + durable per-thread goal	partial (read-only daemons)	DEFER (cost-negative)	M	L	burns proxy $ on free tier
Taint-origin background safety	partial (autonomy tiers exist)	DEFER (bundle)	L	S	polish
MCP live registry discovery (Smithery)	static 200+ + Composio on-demand	DEFER (near-SKIP)	L–M	M	redundant w/ Composio
Memory-diff (git-backed change tracking)	missing	DEFER	M	L	compliance/ already covers audit
SuperContext first-turn scout	has (warm-start)	SKIP	—	—	redundant
Trees / Obsidian / scoring / E2GraphRAG	has / ahead	SKIP	—	—	redundant w/ SOTA moat
Pluggable external memory backend	partial (export-only)	SKIP	—	—	KVARK does sovereign on-prem
90k-entry skills aggregation	curated marketplace	SKIP	—	—	cannibalizes tier trigger
Native voice (STT/TTS + lip-sync)	missing	SKIP	—	—	off-brand (B2B cockpit)
Desktop mascot (Rive)	missing	SKIP	—	—	off-brand
Google Meet agent (CEF/CDP)	missing	SKIP	—	—	multi-quarter, fragile, diff product
Screen intelligence (macOS Vision + Ollama)	partial (browser only)	SKIP	—	—	macOS-only, commodity
iOS companion / 18 messaging channels	missing	SKIP	—	—	mobile v2+; off-funnel
OS keyring	has (vault.ts AES-256-GCM)	SKIP	—	—	vault better for server/KVARK
Theme Studio	has (Hive DS tokens)	SKIP	—	—	brand consistency intentional
Kanban / approval / cron / iteration-budget / loop-guard / awareness	has	SKIP	—	—	already shipped

* Impact is workload-dependent: high for tool/connector-heavy sessions (JSON list responses, web research); low for memory-recall-dominated sessions. Stated honestly, not oversold.

---

3. ADOPT / ADAPT Specs

A. Tool-Result Compression — pure-code subset only (cost lever)

What to build: one pure-TS module packages/agent/src/tool-output-compressor.ts, invoked in tool-executor.ts between tool.execute() and the return, under a hard contract — never enlarge output, never throw, fall through to passthrough; passthrough below a ~2KB gate (exactly TokenJuice's guard). Two compressors plus a deterministic kind-classifier. Explicitly reject tree-sitter, the 96-rule overlay, ModernBERT, and CCR retrieval markers.

1. JSON-table crusher — array-of-objects → pipe-delimited table; force-keep head/tail rows + any row containing error/panic or a numeric outlier (>2σ). Pure JSON.parse + format; ~95% reduction on API list responses. No LLM.
2. Live search-result dedup — call the trigram fuzzy-dedup already in harvest/dedup.ts (75% threshold) on web_search snippets before formatting. The logic exists; it is simply never invoked on real-time results today. No LLM.
3. (minor) Token-aware truncation — replace the blunt 10K-char cut in web_fetch (system-tools.ts:701-730) with a token-estimated budget so the cap is consistent across prose/code/JSON. No LLM.

Explicitly NOT building: the LLM-summarization-on-truncation fallback. It is largely redundant with the existing message-level summarizer (context-compressor.ts at 50%, messages-compressor.ts with COMPACTION_PROMPT), and replacing a free hard-slice with a budget-model call adds proxy cost on FREE/TRIAL — net-positive only when a large result is followed by many turns. If data-loss complaints actually appear, revisit then.

Files: new packages/agent/src/tool-output-compressor.ts; insert at tool-executor.ts:161; system-tools.ts:701-730 (web_fetch path); reuse packages/hive-mind-core/src/harvest/dedup.ts.

Tier: ON for all tiers, ungated — pure margin protection where Waggle funds the proxy.

Cost/security: Net reduction, zero added LLM cost. Only risk is over-compression hiding signal — mitigated by the force-keep rule + never-enlarge contract. Compressed output still passes the existing scanForInjection() (already runs post-tool).

B. Capability-Aware Routing — deterministic internal-call subset (cost lever)

What to build: route a fixed allowlist of known-lightweight internal calls — the compaction summarizer, the kind-classifier from §A, tool-name selection, short structured-extraction — to the cheapest ready class: Haiku on the built-in Anthropic proxy by default, local Ollama when configured. No new classifier; the call sites are known a priori, so routing is deterministic and low-risk.

Why this is a real FREE-tier lever: the built-in proxy is Anthropic-only, so the universal win is Haiku-on-proxy for lightweight work (~10–12× cheaper than Sonnet, far cheaper than Opus) — it materializes for a vanilla FREE user with no local model. Ollama/on-device is the bonus for configured users.

Bundle the privacyRequired flag: forces on-device, no cloud fallback. This is the only piece with a KVARK-funnel angle — surface as a TEAMS/ENTERPRISE-flavored capability ("sensitive tasks never leave the machine"), reinforcing the sovereign narrative with zero KVARK work. Keep it honest: it's a narrative asset, not KVARK itself.

Explicitly NOT building: classification of arbitrary user-task complexity — that needs its own (cost-bearing) classifier and risks mis-routing real reasoning to a weak model. The deterministic internal-call subset captures most of the savings with none of the risk.

Files: extend model-availability.ts:86-109 (resolveUsableModel gains a class arg); routes/litellm.ts (already aggregates 13 providers incl. Ollama); add a model-capability dimension alongside the source dimension in capability-router.ts. Quality fallback: if a local result looks like a refusal/garbage, retry on cloud — unless privacyRequired.

Tier: routing-to-cheap universal; privacyRequired surfaced as a paid-tier capability.

Synergy: B is the prerequisite that makes item C (auto-fetch) cost-safe — its extraction step routes here.

C. Auto-Fetch Connector→Memory Loop — PRO-gated (moat + tier trigger)

What to build: a connector_fetch cron job type wiring the existing scheduler to the existing harvest pipeline, on a frequency-capped schedule (daily, not 20-min), so a user's mind stays current without manual re-harvest. This is the only item touching the actual memory+harvest moat — a mind that silently stays fresh is stickier (deeper lock-in) than one that goes stale.

Why it clears the bar where metering doesn't: the grounding names this the substrate gap; the infra already exists; and PRO-gating resolves every objection at once — it removes FREE proxy exposure, turns "your mind stays fresh automatically" into a concrete upgrade trigger, and deepens the moat for paying users. Triple fit (moat + tier trigger + cost-safe) — the most on-strategy item in this report.

Cost is bounded, not open-ended: harvest's harvestSetHash skips unchanged sources (steady-state cost is only incremental new data), and the extraction LLM routes through §B to the budget model. The expensive first ingest stays user-triggered.

Files: add job type in packages/core/cron-store.ts; wire execution in routes/automations.ts; invoke packages/hive-mind-core/src/harvest/pipeline.ts; gate via tier check.

Tier: PRO+ only. Do not ship on FREE.

(folded in) Savings telemetry — internal only

Extend cost-tracker.ts (per-model pricing already lives there) with a tokensSaved / by_compressor / by_model accumulator to validate A and B internally. No user-facing "we saved you N tokens" panel — that is speculative scope creep. Build only enough to prove the cost arc to the founder.

---

4. SKIP / DEFER (one-line reasons)

SKIP:

• SuperContext first-turn scout — redundant; Waggle warm-starts memory synchronously before the LLM (orchestrator.recallMemory, Hermes session-start). A scout sub-agent adds a round-trip for marginal gain.
• Memory substrate (trees / Obsidian / scoring / E2GraphRAG / pluggable backend) — at-parity-or-ahead; the SOTA-benchmarked moat. Pluggable backend is a real enterprise-sync gap, but that's precisely what KVARK's sovereign on-prem covers; desktop is local-first by design.
• 90k skills aggregation — a free external firehose undercuts the curated marketplace that is the upgrade trigger.
• Voice + lip-sync / Rive mascot — off-brand for a B2B cockpit + demand-gen funnel; OpenHuman's own analysis calls them commodity.
• Google Meet agent — multi-quarter Rust CEF/CDP build, breaks on every Meet UI change, different product than a memory cockpit.
• Screen intelligence — macOS-only, Ollama-heavyweight, commodity OCR+vision; computer-use can wait.
• iOS companion / 18 messaging channels — mobile is v2+; consumer chat platforms are off-funnel.
• OS keyring — vault.ts (AES-256-GCM, icacls-hardened) is already stronger for server/Docker/KVARK; keyring is end-user convenience, not a moat.
• Theme Studio — Hive DS brand consistency is a deliberate moat; user theming dilutes it.

DEFER (real, but gated):

• Trigger triage pipeline — adopt the design (drop/ack/react/escalate on a fast model) only once the event-trigger/webhook layer it depends on actually exists (C24 is explicitly schedule-only v1). Blocked on a prerequisite, not on merit.
• Subconscious idle cognition + durable per-thread goals + taint-origin — genuine capability gap, but idle agent loops burn Waggle-funded proxy on FREE/TRIAL — actively against the cost discipline that justifies this whole report. Defer until there's a PRO tier-trigger case and a quiet-tick/local-eval zero-cost model; that cost model is the real prerequisite.
• MCP live registry discovery — near-redundant with Composio's on-demand discovery (grounding: Composio "exceeds static-only registries"). Revisit only if catalog staleness becomes a stated sales objection; no evidence it is today.
• Memory-diff (git-backed change tracking) — a genuinely moat-adjacent idea for a memory product, but L effort and compliance/ already covers audit/EU-AI-Act; fold into a future compliance sprint.

---

5. Ranked Top Recommendations

The bar culls hard. Three items clear it — ranked by strength of case, with scope cut to the bone:

1. PRO-gated auto-fetch connector→memory (§3.C). The only item touching the actual memory+harvest moat, not just margin. Grounding-flagged as the sole substrate gap; infra already exists (cron-store + harvest/pipeline); PRO-gating makes it cost-safe and a tier trigger in one move. Highest strategic ceiling. M effort; depends on connectors being connected, so size it as a deliberate PRO-feature bet, not a quick win.

2. Tool-result compression — pure-code subset (§3.A). Lowest effort/risk, cleanest pure-margin cost lever. Verified gap (agent-loop.ts:511 verbatim append). JSON-table crusher + live search dedup, both zero added LLM cost, reusing harvest/dedup.ts. Compounds across accumulating turns. Scope discipline is the whole game: ship the crusher + search dedup + token-aware truncation; reject tree-sitter, the 96-rule overlay, the ML compressor, CCR, and the LLM-summarization fallback.

3. Deterministic routing of internal-lightweight calls (§3.B). Complementary cost lever via Haiku-on-proxy (works for vanilla FREE users, no Ollama needed), and the enabler that makes #1's extraction step cheap. Bundle the privacyRequired on-device flag as a free KVARK-sovereignty narrative asset.

Folded in, not headlined: internal savings telemetry via cost-tracker.ts — build enough to prove #2/#3, no user-facing panel.

Everything else: defer behind explicit triggers (triage, Subconscious, MCP discovery, memory-diff) or skip. Do not let OpenHuman's impressive-but-off-strategy surfaces (Meet, mascot, voice, screen, mobile, 90k skills) pull scope — real engineering, not Waggle's funnel.

---

6. Critique Deltas (what I changed vs the draft and why)

1. Split the compression layer; dropped the LLM fallback. The draft bundled a genuine zero-cost win (JSON crusher + trigram search dedup, both pure code) with token-aware-truncation-with-LLM-summarization. I demoted the summarization fallback to DEFER because it is (a) largely redundant with Waggle's existing message-level compression (context-compressor.ts at 50%, messages-compressor.ts), and (b) cost-perverse on the target tier — a hard slice is free, a budget-model summary spends proxy tokens, net-positive only for long post-result conversations. The ruthless cut sharpens the rec to its zero-added-cost core.

2. Demoted "savings metering" from a co-equal top-3 ADOPT to internal telemetry. A user-facing "we saved you N tokens" panel is exactly the nice-but-not-differentiating scope creep the founder rejects. Kept only the near-free internal cost-tracker accumulator needed to validate the arc. This freed the #3 slot for a real moat item.

3. Elevated auto-fetch connector→memory from mid-DEFER to ADOPT (PRO-gated). This is the biggest change and the one place I make the strongest case. The grounding names it the sole substrate gap; it's the only candidate touching the actual memory+harvest moat rather than margin; PRO-gating eliminates the FREE cost exposure the draft worried about and converts it into a tier trigger. Triple strategic fit beats every cost-only item. The draft's cost objection is over-stated: harvestSetHash bounds steady-state cost, and routing (rec B) makes extraction cheap.

4. Scoped routing down to deterministic internal calls; cut the task-complexity classifier. The draft proposed classifyTaskComplexity(intent) over arbitrary user tasks — that needs its own cost-bearing classifier and risks mis-routing real reasoning. I kept only the deterministic allowlist (summarizer, kind-classifier, tool-selection → Haiku/local), and made explicit that Haiku-on-built-in-proxy (not Ollama) is the universal FREE-tier lever — the draft over-weighted Ollama, which requires user setup most FREE users won't have.

5. Corrected a file pointer. agent-loop.ts:504 → :511 per the authoritative grounding ("line 511, r.content added verbatim").

6. Re-characterized MCP live discovery as near-redundant with Composio. Grounding states Composio on-demand discovery "exceeds static-only registries," so Smithery live discovery is closer to SKIP than DEFER — kept DEFER but flagged the redundancy and the lack of any evidence catalog staleness is a real objection.

7. Sharpened Subconscious as cost-negative. The draft deferred it neutrally; I flagged that idle background loops burn the Waggle-funded proxy on the exact moat tiers, cutting directly against the cost discipline that justifies the rest of the report — so it's not just "later," it's "not on FREE, ever, without a zero-cost tick model."

8. Reframed the honest verdict. Replaced the draft's "one cluster of three small modules (compression + routing + metering)" with the more accurate and more strategic framing: two tightly-scoped cost levers + one PRO-gated moat-deepener (auto-fetch), metering folded in. Same restraint, but the third item now touches the moat instead of being instrumentation.

9. Held all SKIPs. Re-tested every SKIP (voice, mascot, Meet, screen, mobile, keyring, Theme Studio, pluggable backend, 90k skills, scout, substrate) against the bar — all correctly skipped; no false negatives to rescue.