SCAVENGE · IMPLEMENT

Siftly ALPHA Board

Exhaustive 1211/1211 · Live DB bookmarks via Rain · Generated 2026-07-29 16:02 UTC

Status

  • Exhaustive LLM: 100.0% (1211/1211)
  • TOP50 implement items: 50
  • Primary receipts: ketron-receipts-3880316f
  • Scavenge pack: ~/src/scavenge-ai-marketing-skills (26 modules)
  • Same-page: ~/.hermes/state/meta-ooda/LIVE-ALIGNMENT.json

Scavenge modules cloned

  • autoresearch
  • clone-site
  • closed-loop-analytics-upgrade
  • content-eval
  • content-ops
  • conversion-ops
  • deck-generator
  • eval
  • finance-ops
  • growth-engine
  • lead-dossier
  • outbound-engine
  • personal-strategic-signal-intelligence
  • podcast-ops
  • revenue-intelligence
  • sales-pipeline
  • sales-playbook
  • security
  • seo-ops
  • short-form-pipeline
  • team-ops
  • telemetry
  • video-caption-generator
  • video-clip-pipeline
  • x-longform-post
  • yt-competitive-analysis

How Rain uses this

  1. Pick P0 row
  2. Scavenge module or skill already on disk
  3. Implement/adapt into Ketron/NEXUS product path
  4. Publish receipt to CF Pages

TOP50 level-ups (implement these)

#PScoreAlpha
1P0114
User describes a Codex App that wires Gmail, Calendar, Drive, Sheets & Presentations plugins together, turning scattered personal data into a single professional layer that doubled their organization.
Insight: A thin orchestration layer over existing productivity APIs can instantly convert a chaotic personal life into a reliable, professional-grade system without rebuilding any of the underlying tools.
  • Add one-click Gmail/Calendar/Drive plugin onboarding so Rain can read/write user life data without leaving the voice mesh
  • Expose a 'professional mode' toggle that routes all life data through the same orchestration Rain already uses for work agents
agent_orch, life_ops, skills, openai
2P0112
Tweet advises winning in 2026 by building a personal agent harness powered by a model council: frontier model as orchestrator, cheaper models for decisions, minimal tools/plugins, heavy focus on knowledge base, and perfect prompt crafting.
Insight: A lightweight council of heterogeneous models (one expensive orchestrator + many cheap specialists) beats monolithic agents when paired with a rich, curated knowledge base instead of sprawling tool/plugin sprawl.
  • Add explicit council mode: designate one Grok-class orchestrator and route sub-tasks to cheaper local or API models while sharing the same life-mesh memory
  • Surface a 'knowledge base soak' toggle that freezes ambient agents until the KB is updated, then releases them
agent council, orchestrator + specialists, knowledge base primacy, minimal tooling
3P0110
Tweet pointing to an article or thread as the current state-of-the-art in AI memory systems.
Insight: SOTA memory is no longer just retrieval—it's a living, structured substrate that agents continuously read/write with explicit lifecycle rules.
  • Add explicit memory lifecycle hooks (write, consolidate, prune) exposed to Pipecat Grok S2S so Rain agents can evolve memory without full context reload
memory, agent_state, long_context
4P0110
Tweet about building an LLM Wiki that encodes every employee's responsibilities, workflows, and operational context so the system can understand how work is organized before acting.
Insight: Treat the org chart, roles, and workflows as first-class structured memory the agent reads before every action, turning humans from bottlenecks into living context.
  • Auto-ingest org chart, role definitions, and workflow docs into Rain's life mesh so every agent call starts with 'who does what' context
memory, org_context, workflow_capture
5P0110
Tweet about Zac O'hara of North Shore Masonry (no coding experience) building an AI agent that automates time-consuming business operations.
Insight: Non-technical SMB operators can ship production-grade agents that replace manual ops work when given the right no-code/low-code path and clear business constraints.
  • Add one-click vertical template for masonry/roofing ops (scheduling, follow-ups, job intake)
  • Expose a 'no terminal' onboarding flow that lets users describe their business in plain language and get a running agent
no-code agent builder, SMB automation, ops replacement, masonry/roofing vertical
6P0110
Tweet highlights how a roofing company lost a lead because their phone went straight to a full voicemail, illustrating why home service businesses stay small despite available demand.
Insight: The bottleneck isn't lead generation—it's real-time human or agent availability; missed calls equal missed revenue.
  • Auto-answer roofing inbound calls with NEXUS voice agent that books estimates on the spot or queues with context for human follow-up
lead capture, availability, SMB ops friction
7P0110
Bookmark captures the idea that life is an interconnected system—ignoring one failing piece drags everything else down, and the common error is attempting to fix isolated symptoms instead of the whole.
Insight: Treat life (and agent state) as a single mesh where one degraded node can cascade; the fix is holistic re-soak rather than piecemeal patches.
  • Add mesh-wide health score that triggers full re-soak when any single agent or memory node drops below threshold instead of local fixes
interconnected systems, cascade failure, holistic repair
8P0110
Tweet outlines a minimal 80/20 AI second brain: 3 folders (raw/, processed/, archive/) plus one schema file to organize all inputs without over-engineering.
Insight: Radical simplicity beats elaborate knowledge graphs—three buckets plus schema is enough structure for an AI to reliably index and retrieve personal/business data.
  • Add native raw/ drop-zone that auto-watches local folders and bookmarks; enforce single canonical schema.json for all agents to read/write against
memory, life_ops, business, minimalism
9P0110
Tweet highlights domain-specific "chips" (tiny specialist agents) as underrated compared to loops, each chip optimized for one narrow job like QA, trading, content, or research instead of a monolithic brain.
Insight: Specialist micro-agents beat generalist mega-models when the task is narrow, repeatable, and high-stakes; compose them instead of scaling one model.
  • add pluggable domain-chip registry so Rain can spin up a roofing-pricing chip or permit QA chip on demand
  • expose chip marketplace so users can drop in their own specialist without retraining the whole agent
agent_orch, specialist_agents, modular_ai
10P0110
Outlines a 6-layer Company Brain stack starting with Level 1 capture (calls, CRM, Slack, SOPs, feedback) and Level 2 retrieval as the foundation for agentic work.
Insight: Raw unstructured inputs must be captured before any retrieval or reasoning layer can produce coherent outputs; scattered sources guarantee scattered agent answers.
  • Add always-on capture connectors for phone calls, Slack threads, and CRM notes with automatic transcription and tagging
  • Implement a retrieval layer that surfaces captured artifacts before any agent response
life_ops, business, memory, retrieval
11P0110
Bookmark about Boris Cherny (Claude Code creator) explaining why most users fail to get real results from Claude: they skip the critical setup step that enables 90% of Anthropic's code to be written by Claude.
Insight: The difference between toy usage and production-grade agent output is not model capability but the invisible scaffolding (context, rules, memory, orchestration) that must be pre-loaded before the agent ever starts.
  • Add explicit 'setup soak' phase before any agent session begins, where Rain loads all four hard constraints, life mesh, and ambient context so the first user message already runs at Anthropic-level effectiveness.
agent_setup, scaffolding, production_vs_toy
12P0110
Tweet about SOUL.md as the single hand-written file that sits at the very top of an AI agent's system prompt, defining its identity before memory, skills, or tools.
Insight: Identity should be authored once in a dedicated, human-curated file that precedes all dynamic context rather than being scattered across prompts or learned on the fly.
  • Add a user-editable SOUL.md file that Rain loads first on every session, before any mesh memory or skills, with a simple local editor or voice command to update it.
identity, prompt-architecture, memory
13P0110
Tweet contrasts legacy org charts (functions, handoffs, labor arbitrage) with a new AI-forward model built on outcomes, agent fleets, loops, and systems memory that writes back to the company.
Insight: Replace static roles and handoffs with persistent agent fleets whose every workflow writes structured memory back into a shared company system.
  • Add explicit 'memory writeback' hooks so every Rain agent workflow auto-commits structured outcomes to a shared life-mesh store
  • Expose per-agent outcome metrics that each agent must own and report
memory, business, agent_fleets, loops
14P0110
GBrain v0.40.0 adds a Gemini Live-based voice layer to OpenClaw/Hermes agents, giving them full brain/tool access and naming Mars/Venus personas.
Insight: Voice is the final mile for agent orchestration—attach a live duplex channel to an existing agent graph and the whole mesh suddenly feels ambient and always-on.
  • Expose a one-line Gemini-Live adapter so any Rain agent can become voice-native without re-arch
  • Ship Mars/Venus-style persona toggles as first-class Rain skills
voice_duplex, agent_orch, memory, local
15P0108
Bookmark warns about AI agents accidentally deleting files and recommends using hooks as a safeguard, referencing a GPT 5.6 Sol incident with @mattshumer_.
Insight: Hooks as a last-line safety net that intercept destructive actions before they execute, especially critical when new models behave unpredictably.
  • Add mandatory pre-action hooks for file system, email, and API calls that require explicit user soak before proceeding
  • Implement model-agnostic safety hooks that trigger ambient freeze on high-risk actions regardless of which LLM is active
safety, agent_guardrails, destructive_action_prevention
16P0108
Tweet about Anthropic's internal memory system using a massive knowledge graph (8,893 connected notes) to solve AI agent session amnesia.
Insight: Persistent agent memory via a single, densely-linked knowledge graph beats stateless per-session context.
  • Replace per-session vector store with a live, link-dense knowledge graph that grows across all Rain agents and sessions
memory, knowledge_graph, persistence
17P0108
Tweet about managing 10-15 parallel AI agent threads daily (Hermes, OpenClaw, Claude Code, Codex) and the output cliff that appears past a certain concurrency threshold.
Insight: Raw parallelism hits diminishing returns; coordination overhead and context bleed destroy gains once thread count exceeds human oversight capacity.
  • Add automatic thread throttling + soak gating when active agent count > N
  • Surface a single 'life mesh' dashboard showing cross-agent state collisions
agent_orch, parallelism, context_management
18P0108
Tweet urges building a hyper-personalized, all-in-one AI app that tracks business, health, todos, and projects—framed as the highest-leverage use of AI today.
Insight: The real moat is not the model but the private, continuously-updated personal data graph that only you control.
  • add persistent personal memory layer that survives session end and surfaces cross-domain insights (business + health + tasks)
personal data mesh, life OS, single-user agent
19P0108
Stanford 32-page guide on building compounding memory for AI agents via act → reflect → curate into playbook → repeat loop instead of rewriting context each time.
Insight: Memory should be treated as a living, growing playbook artifact rather than ephemeral prompt context that gets discarded or rewritten.
  • Add explicit reflect-and-curate step after every agent action that writes to a persistent playbook
  • Expose playbook as editable, versioned artifact users can inspect and trust
memory, compounding knowledge, reflection loops
20P0108
Sierra's internal agent Pinecone automates 90% of coding, analytics, and busywork via an agentic harness in their internal cloud that connects to Slack, GitHub, Linear, and GSuite.
Insight: A single persistent internal agent that owns the full work graph (code + tickets + comms) becomes irreplaceable once it crosses the 90% automation threshold.
  • Add a persistent 'Pinecone mode' that lives inside the user's internal cloud and owns the full tool graph (Slack, GitHub, Linear, calendar) instead of one-off calls
agent_orch, life_ops, internal_agent
21P0108
A 26-year-old dev shipped a one-command tool that turns any folder (code, docs, PDFs) into a graph memory store, delivering 71.5x token savings and 76k GitHub stars just 48 hours after Karpathy floated the LLM wiki idea.
Insight: Graphify local content on the fly instead of vectorizing it; the structure itself becomes the memory substrate, eliminating the need for a separate vector DB.
  • add `nexus graphify <folder>` command that builds a live graph index for Rain agents
  • replace or augment vector retrieval with graph traversal for 70x token reduction
memory, graph, local-first, zero-infra
22P0108
Open-source local agent hit 200k stars; runs entirely on laptop with persistent memory and self-improving code.
Insight: A single SOUL.md file can encode personality + long-term memory so the agent never forgets and keeps improving itself from local files.
  • add SOUL.md-style personality file that Rain can read/write to evolve its voice and rules locally
local-first, persistent memory, self-improving agent
23P0108
Tweet frames a 3-tier maturity model for AI-native companies: connectors to core systems, skill-sharing layer on top, and an overarching "company brain" for knowledge/rules/projects.
Insight: The real differentiator isn't more connectors—it's the meta-layer that turns raw system access into shareable, evolving organizational intelligence.
  • Add a company-brain mode that ingests rules/learnings/projects and surfaces them as ambient context for any agent session
  • Build a skill marketplace where agents publish/reuse connectors and prompts across the mesh
company brain, skill sharing, system connectors, organizational intelligence
24P0108
Bookmark of a 130+ page survey on always-on agents: systems whose future behavior is shaped by durable state accumulated across interactions, treating state as more than memory.
Insight: State is not just retrieval fodder—it is the substrate that continuously rewires what the agent will do next, turning history into live policy.
  • Make Rain’s life mesh the explicit substrate that rewires agent behavior on every soak instead of just storing facts
always-on agents, durable state, jarvis, memory
25P0108
Tweet exposing that OpenAI Codex CLI has been silently writing every websocket event and telemetry trace to a local SQLite DB (~/.codex/logs_2.sqlite) since February at TRACE level.
Insight: Full-fidelity local event capture is already happening in production agents; the only missing piece is making it queryable, ambient, and first-class for the user instead of hidden forensic logs.
  • Expose ~/.rain/logs/*.sqlite as first-class queryable memory mesh
  • Add soak-time ambient freeze that writes every Pipecat frame at TRACE level without user action
agent_orch, local, openai, telemetry, trace
26P0108
User describes shifting from app-centric to task-centric computing by using Codex agents to manage correspondence across Mail, Messages, and Slack in a single thread.
Insight: Agents collapse multiple apps into persistent task threads, turning messaging into a background service rather than a foreground app.
  • Add 'Manage correspondence' as a first-class ambient task that owns all messaging channels and surfaces only when action needed
agent_orch, life_ops, task_threads
27P0108
Perplexity launches 'Brain' — a continuously learning memory system that turns every Computer task into a growing context graph, making the product progressively more stateful.
Insight: Memory isn't a static store; it's a live context graph that accretes state from every user action, turning one-off tasks into compounding intelligence.
  • Make every Rain agent action write to a shared life-mesh context graph so future sessions inherit state without explicit recall
  • Expose a 'Brain view' toggle that shows the growing context graph for the current mesh
memory, context_graph, stateful_agents
28P0108
Tweet contrasts human working memory limits (7±3) with AI's ability to hold massive context, positioning GBrain as the retrieval layer that loads the right 3 books from a 300k-book library into an agent's context.
Insight: Dynamic, task-specific context loading from a massive personal knowledge base is the real unlock, not just bigger context windows.
  • Add GBrain-style retrieval so Rain can surface the exact 3 relevant books/docs from a user's 300k-item library into the active S2S context without user prompting.
memory, retrieval, context_management
29P0108
Tweet outlines a fully-local private AI stack: high-RAM machine running Hermes + local models, a private gateway, llm-wiki for persistent knowledge, and gbrain layered on top.
Insight: Treat the wiki itself as the long-term memory substrate; the LLM only reasons over it instead of holding state in context.
  • add wiki-backed memory mesh so agents can soak/freeze over structured notes instead of flat context
  • expose local-gateway endpoint so Rain agents stay private across devices
memory, local, privacy, wiki-as-memory
30P0108
User describes using Claude to live-transcribe a customer call and instantly build requested features in real time, turning feedback into working software by call end.
Insight: Live voice-to-code loop where customer desires are captured and materialized during the conversation itself, collapsing feedback-to-prototype latency to zero.
  • Add always-on background transcription agent that emits working prototypes or config patches before call ends
  • Expose a 'call co-pilot' mode where Rain materializes requested features as live UI or backend stubs in real time
live voice-to-code, real-time feature synthesis, customer-call co-creation
31P0108
Tweet argues internal tools are the highest-leverage, least-hyped AI use case—operators are quietly shipping the software that actually runs their companies.
Insight: The real moat is not flashy consumer apps but AI that lets non-engineers build and maintain the exact internal workflows their business depends on.
  • Add a one-click "internal tool" mode that scaffolds a private agent workspace for a specific business process (e.g., job scheduling, invoice review) with zero public exposure.
internal tooling, operator-built software, AI for ops
32P0108
Tweet about one person rebuilding an entire company's brain as a living, clickable galaxy of nodes (employees, agents, SOPs, tools) inside Claude Code in 7 days.
Insight: Treat the org as a single navigable graph where humans, agents, and processes are first-class nodes you can click into, not scattered docs or folders.
  • Add a clickable org-galaxy view where departments expand to show human+agent teams and their SOPs as live nodes
  • Expose a 'rebuild company brain' mode that ingests existing SOPs/tools and wires them into the mesh in <7 days
agent_orch, memory, claude, org_graph
33P0108
Tweet identifies company-specific tacit knowledge locked in senior heads as the real bottleneck, not model intelligence, and flags GBrain as a potential extraction tool.
Insight: The scarce resource is not model capability but structured extraction of distributed institutional memory.
  • Add passive, always-on extraction layer that turns senior Slack/Loom/email into structured life-mesh nodes without explicit prompting
memory, knowledge extraction, institutional context
34P0108
Thread on 40+ FDE engagements claiming Context Extraction is the hardest part of shipping AI agents; FDE role = consulting + product + engineering.
Insight: Context extraction—not model quality or infra—is the real bottleneck; it requires a hybrid consulting/product/engineering skillset.
  • Add an explicit Context Extraction mode that records and tags ambient conversation + screen activity during FDE-style shadowing sessions, auto-generating a living business-context mesh for the agent.
context extraction, forward deployed engineering, agent deployment friction
35P0108
User discovered that feeding agents their own past chat logs is more powerful than manually writing docs, because the logs form a living chronological story of work and intent.
Insight: Chat history itself is the highest-fidelity, zero-friction knowledge base for agents; no separate docs needed if agents can read their own history.
  • Add one-click 'soak my history' that lets Rain agents ingest and index all prior sessions as first-class memory before any new task
  • Surface 'what have we been building?' summaries pulled directly from chat chronology instead of user-written notes
self-referential memory, chat-as-knowledge-base, agent self-awareness
36P0108
User describes a persistent "chief of staff" Codex thread that spawns fresh project threads while carrying forward context from Slack and other sources.
Insight: Single long-lived orchestrator thread that owns context discovery and then delegates to short-lived specialist threads, turning memory into a spawning mechanism rather than a growing blob.
  • Add a default persistent Rain CoS agent that auto-detects new workstreams and spawns isolated child agents with inherited context
agent_orch, memory, life_ops, openai
37P0108
Tweet claims retrieval latency is the universal bottleneck for voice AI and positions Moss as an open-source, sub-10 ms local vector search layer that eliminates network hops.
Insight: Move retrieval inside the same process / box as the voice agent so the think→search→speak loop stays under human-perceptible latency.
  • embed Moss-style in-process vector index so Pipecat Grok S2S agents can retrieve memories with <10 ms latency without leaving the edge runtime
memory, local, latency
38P0108
Tweet about an Obsidian + Vellum setup that keeps persistent memory of the user across sessions, unlike typical stateless AI chats.
Insight: Externalizing long-term user context into a personal knowledge base so the AI can reference goals, history, and notes without re-prompting.
  • add Obsidian vault sync so Rain can read/write user notes as persistent memory layer
  • expose a toggle to treat selected folders as Rain's long-term memory
memory, personal knowledge graph, persistent context
39P0108
Google will launch AI agents this summer that place outbound calls to home-service businesses on behalf of customers, so CSRs will start fielding AI-generated calls before any human homeowner ever dials.
Insight: The first point of contact for many service jobs is shifting from the homeowner to an AI intermediary that negotiates availability, pricing, and scheduling before a human ever joins the call.
  • add an explicit 'Google Agent Mode' that answers with structured JSON slots (availability, price band, job type) instead of free-form chat
  • auto-detect synthetic voice cadence and surface 'AI Caller' badge to CSR
AI-to-business calling, home services automation, CSR displacement
40P0106
OpenAI just released GPT-5.6 Sol Ultra and claims it solved the 50-year-old Cycle Double Cover Conjecture in under an hour using 64 subagents.
Insight: Massive parallel subagent swarms can compress decades of mathematical research into minutes when the right orchestration and verification loop is in place.
  • Add explicit 'swarm size' slider (1-128) with auto-scaling based on task complexity
  • Expose a 'formal verification' mode that spins up verifier agents to check every claim before surfacing
multi-agent orchestration, mathematical discovery, swarm verification
41P0106
Bookmark stresses that in AI search/LLMs, success depends on embedding your unique story, terminology, and receipts into the model's training data rather than ranking pages like Google.
Insight: LLMs don't retrieve documents—they recall entities, so owning the canonical language, receipts, and narrative around your domain becomes the new SEO.
  • Train Rain on Mitch's exact terminology, receipts, and narrative so it becomes the canonical entity for NEXUS voice agent queries
entity recall, canonical narrative, data diet
42P0106
Bookmark about Meta research on fixing long-horizon agents that suffer from behavioral state decay—forgetting previously made decisions and task facts.
Insight: Agents need explicit mechanisms to preserve and re-inject decision history instead of relying on context alone.
  • Add a lightweight decision ledger that agents must consult before replanning; surface forgotten decisions as ambient reminders during soak
agent memory, long-horizon planning, state decay
43P0106
Tweet praising a file-based pattern (AGENTS.md) that encodes hard rules, scope, and commands so agents stop re-introducing fixed mistakes.
Insight: Treat the agent’s operating contract as a single, version-controlled artifact that lives next to the code instead of in chat history or system prompts.
  • Auto-generate and sync AGENTS.md from Rain’s four hard constraints whenever the mesh updates
  • Surface AGENTS.md diff in the UI so users see exactly what the agent is now forbidden/allowed to do
persistent agent memory, constraint files, forgetting prevention
44P0106
Bookmark captures the mental shift from effortful, revision-minimizing creation to freely throwing raw ideas at AI and iterating on output.
Insight: The biggest blocker to AI leverage is not capability but the ingrained habit of conserving mental energy for perfect-first-draft thinking instead of rapid idea-dumping.
  • Add one-tap 'idea dump' mode that records raw voice fragments without requiring structured prompts, then auto-spawns parallel agents to explore each fragment
mental model shift, idea velocity, low-friction creation
45P0106
Tweet argues that any agent with write access (bookings/refunds) must be gated by a 6-line operating file: allowed action, approval line, spend cap, owner, rollback note, customer-facing receipt.
Insight: A tiny structured contract file can turn high-risk agent actions into auditable, rollback-able micro-permissions instead of blanket trust.
  • Add mandatory 6-line operating file to every Rain agent that can mutate bookings/refunds; store as versioned JSON next to the agent definition so NEXUS can enforce before any write call.
agent safety, write-access controls, micro-permissions, rollback
46P0106
Tweet positions Pipecat as the evolution beyond naive voice agents, contrasting the classic record→STT→LLM→TTS pipeline with a more integrated approach.
Insight: Voice agents need native duplex streaming and shared state rather than bolted-together sequential stages to feel human.
  • Replace any STT→LLM→TTS glue with native Pipecat S2S duplex streams to cut latency and keep mesh state alive
voice_duplex, product_eng, low_latency
47P0106
User built a shared Obsidian brain graph from a Notion DB using Fable 5, then connected it to both Iris and Hermes agents with Gemini Embedding 2 semantic search.
Insight: One canonical graph can be the single source of truth for multiple agents instead of each maintaining its own memory silo.
  • Expose a shared Obsidian/Notion-backed graph endpoint so every Rain agent instance can read/write the same memory mesh without duplication
shared memory, graph brain, multi-agent sync
48P0106
A Berlin student built a second brain by connecting Claude Desktop to Obsidian locally on the U-Bahn with zero code and four steps.
Insight: Zero-friction local memory mesh via drag-and-drop vault + LLM desktop client creates instant personal knowledge layer.
  • Add one-click Obsidian vault import to Rain so users can seed life mesh from existing notes in <60s
memory, local, claude, second-brain
49P0106
Tweet declares prompt engineering obsolete and elevates "harness engineering" as the new critical skill, linking to a discussion with the founder of Browser Use.
Insight: The real leverage has shifted from crafting clever prompts to building robust harnesses that control, constrain, and orchestrate agent behavior at runtime.
  • Add explicit harness configuration layer so users define runtime constraints, parallel limits, and freeze/soak rules instead of relying on prompt text
  • Expose harness templates for common patterns (e.g., four-hard-constraint mode, ambient freeze until soak)
agent orchestration, runtime control, tooling over prompting
50P0106
A user describes a daily "Thread Introspection" automation where Codex reviews all threads and prompts, extracts preferences and failure patterns, then updates the agent's skills for compounding improvement.
Insight: Self-reflective loop that turns daily usage traces into automatic skill updates, creating rapid compounding without manual tuning.
  • Add scheduled daily introspection job that scans all active threads, extracts user prefs + failure modes, and writes deltas to the skill mesh
agent_orch, self-improvement, memory