From windags-skills
What you can build and do with an always-on AI agent that has episodic memory. Covers concrete product ideas, workflows, emergent capabilities from persistence plus memory, and real-world examples of deployed persistent agents. Helps you go from "I have the architecture" to "here's what it actually does for me." Activate on: "what can an always-on agent do", "persistent agent use cases", "agent applications", "proactive agent ideas", "what to build with episodic memory", "always-on agent product", "personal AI assistant ideas", "/always-on-agent-applications". NOT for: building the architecture (use always-on-agent-architecture), designing inputs (use always-on-agent-inputs), safety and privacy (use always-on-agent-safety).
How this skill is triggered — by the user, by Claude, or both
Slash command
/windags-skills:always-on-agent-applicationsThis skill is limited to the following tools:
The summary Claude sees in its skill listing — used to decide when to auto-load this skill
You are helping someone figure out what to build with an always-on AI agent that has episodic memory. This is the "so what?" skill — the architecture exists, the inputs are flowing, now what does it actually do that a stateless chatbot can't?
You are helping someone figure out what to build with an always-on AI agent that has episodic memory. This is the "so what?" skill — the architecture exists, the inputs are flowing, now what does it actually do that a stateless chatbot can't?
Evaluate task requirements:
├─ Task needs memory across sessions?
│ └─ No → Use session-based agent (cheaper, simpler)
│ └─ Yes ↓
├─ Task benefits from proactive behavior?
│ └─ No → Use scheduled agent with memory
│ └─ Yes ↓
├─ [Persistence ROI] > [Infrastructure Cost]?
│ └─ No → Start with session-based, upgrade later
│ └─ Yes ↓
├─ Domain narrow enough for quality memory?
│ └─ No → Narrow scope (meetings-only, code-only)
│ └─ Yes → Build always-on agent
ROI Calculation:
If ROI > 3x cost: Build always-on If ROI 1-3x cost: Start session-based, prove value first If ROI < 1x cost: Use existing tools
User asks "What should I build?":
├─ Primary workflow is coding?
│ └─ Yes → Developer Companion pattern
│ └─ No ↓
├─ Primary need is meeting/communication overhead?
│ └─ Yes → Personal Chief of Staff pattern
│ └─ No ↓
├─ Primary goal is learning/knowledge work?
│ └─ Yes → Learning Journal pattern
│ └─ No ↓
├─ Focus is health/habits tracking?
│ └─ Yes → Health Observer pattern (high safety sensitivity)
│ └─ No → Project Orchestrator or Ambient Intelligence
User proposes multi-domain agent:
├─ Is this their first persistent agent?
│ └─ Yes → Force single vertical (pick strongest ROI)
│ └─ No ↓
├─ Do they have >6 months development time?
│ └─ No → Single vertical only
│ └─ Yes ↓
├─ Can they define success metrics for each domain?
│ └─ No → Reduce scope until they can
│ └─ Yes → Allow multi-domain with staged rollout
Configure agent interruption frequency:
├─ User work style is deep focus blocks?
│ └─ Yes → Batch notifications, respect focus signals
│ └─ No ↓
├─ User explicitly requests high-touch assistance?
│ └─ Yes → Allow real-time interruptions with relevance threshold
│ └─ No ↓
├─ Default to: 80% reactive, 15% passive proactive, 5% active proactive
Symptoms: Agent confidently references conversations or events that never happened Detection Rule: If agent claims specific quotes/dates/facts but can't provide exact source timestamp Root Cause: Poor memory boundaries between retrieved context and generated responses Fix: Implement strict memory citation requirements - agent must link every claim to specific memory entry with timestamp
Symptoms: Agent performance degrades over time, contradictory information in responses Detection Rule: If agent gives conflicting advice about same topic within 7 days without acknowledging change Root Cause: Low-quality observations accumulating faster than valuable signal Fix: Implement memory hygiene: relevance scoring, automated compaction, user-triggered memory cleanup
Symptoms: Monthly bills increasing 30%+ without proportional value increase Detection Rule: If cost-per-useful-interaction rises above baseline by 50%+ over 30 days Root Cause: Agent over-processing low-value inputs (notifications, spam, automated emails) Fix: Input filtering pipeline, memory access budgets, proactive cost monitoring with auto-throttling
Symptoms: Agent tries to handle everything, excels at nothing, user abandons after 2 weeks Detection Rule: If agent has >5 distinct application verticals without clear success metrics for each Root Cause: Building "general assistant" instead of focused tool Fix: Force single-vertical start, require graduation criteria before expansion
Symptoms: Agent accidentally shares sensitive information across contexts Detection Rule: If agent mentions personal/work details in wrong context (work info in personal chat) Root Cause: Memory boundaries not aligned with user privacy expectations Fix: Context isolation, explicit memory compartmentalization, regular privacy audits
Scenario: Software engineer wants agent to help with code reviews and PR descriptions
Step 1 - Scope Definition
Step 2 - ROI Calculation
Step 3 - Memory Strategy
Step 4 - Trigger Design
triggers:
- git_push_to_feature_branch: Draft PR description
- pr_opened: Enhance description with context
- code_review_received: Log feedback patterns for future
Step 5 - Quality Gates
What novice would miss: Starting with "AI coding assistant for everything" What expert catches: Focusing on single high-value workflow (PR descriptions) where persistence creates clear advantage over stateless solutions
Application design is complete when all conditions are met:
Do NOT use this skill for:
always-on-agent-architecture insteadalways-on-agent-inputs insteadalways-on-agent-safety insteadagentic-patterns insteadai-safety-engineer insteadsystems-architecture insteadDelegate to other skills when user asks:
always-on-agent-architecturealways-on-agent-inputsalways-on-agent-safetyagentic-patternsnpx claudepluginhub curiositech/windags-skills --plugin windags-skillsDesign AI agents with capabilities, knowledge, and context. Guides agent architecture decisions from simple loops to subagents and planning.
Designs and builds AI agents for business, research, operations, and creative domains. Covers architecture, capabilities, knowledge, context, planning, and subagents.
Provides patterns and principles for building reliable autonomous agents: agent loops (ReAct, Plan-Execute), goal decomposition, reflection, and production guardrails. Useful when designing constrained, domain-specific agents.