Curiosity Loop , Intrinsic Curiosity-Driven Continuous Learning

intent

the curiosity loop transforms knowledge gaps and failed outcomes into structured learning cycles. instead of treating failures as errors, it treats them as curiosity signals: prompts for active exploration, skill updates, and curriculum building. use this skill when you encounter unexpected results, repeated corrections, missing knowledge, or suboptimal approaches. it creates a continuous self-improvement loop that makes you progressively better at your domain, grounded in developmental AI research from Flowers Lab, INRIA.

inputs

external connections:

• skill_manage: API or internal function to create/patch skills. requires write access to skill repository (typically ~/.hermes/skills/)
• memory: storage API for durable facts (typically ~/.hermes/memory.json or equivalent)
• web_search: external search capability (curl, requests library, or API wrapper)
• browser: headless browser tool (Playwright, Puppeteer, or Obscura as fallback)
• session_search: internal session/conversation history search
• terminal: shell execution for tool discovery and validation

context required:

• current skill repository structure and naming conventions
• delta tracking file location (~/.hermes/deltas.json), must exist or be initialized on first run
• access to external knowledge sources (docs, GitHub, arXiv, YouTube channels)
• periodic scan schedule config (optional, defaults to manual runs)

optional env vars:

• HERMES_DELTA_PATH: override default deltas.json location (default: ~/.hermes/deltas.json)
• HERMES_SKILL_REPO: override skill repository path (default: ~/.hermes/skills/)
• HERMES_MEMORY_PATH: override memory storage location (default: ~/.hermes/memory.json)

procedure

step 1: action

• execute current approach to solve the problem using existing knowledge and skills
• record the initial attempt, expected outcome, and any observable output
• output: action_log with timestamp, approach used, and actual result

step 2: delta

• compare expected outcome vs. actual outcome
• identify the precise gap: what did not work, why it matters, and cost (time, iterations, resources)
• ask: what was the expectation vs. reality? how much overhead did this create?
• output: delta_report with expected, actual, gap_description, and cost_estimate

step 3: curiosity

• reframe the delta as a learning signal, not failure
• ask: what concept, tool, pattern, or fact was missing?
• ask: why was this information important for the domain?
• ask: have i encountered hints of this gap before?
• output: curiosity_signal with gap_category (concept/tool/pattern/fact) and importance_rating (1-5)

step 4: research

• search docs, existing skills, arXiv, GitHub, web for the missing concept
• validate discovery relevance: does it close the gap? is it production-ready?
• document all sources and findings
• output: research_report with sources, findings, validation_notes, and relevance_score (1-10)

step 5: integration

• execute one of the following based on discovery type:
  • existing skill is incomplete: call skill_manage(action='patch', skill_name=X, updates=...) with new info
  • new pattern is discovered: call skill_manage(action='create', skill_name=new_name, content=...) for new skill
  • stable fact is learned: call memory(action='add', fact=X, category=Y, confidence_level=Z) for durable knowledge
  • tool or command is discovered: document in appropriate existing skill or create new one
• output: integration_log with action_type, target (skill_name or memory_id), and change_summary

step 6: curriculum

• identify prerequisites for the learned concept (what must come first?)
• decompose concept into 2-4 progressive sub-concepts or milestones
• create verifiable checkpoints: can i explain this? can i use it? can i teach it?
• output: curriculum_document with milestone_sequence and verification_criteria

delta logging (after all steps):

• append to ~/.hermes/deltas.json with id, date, context, expected, actual, gap, resolution, skill_updated, status
• keep delta record for audit and periodic review

decision points

activation: activate curiosity loop if and only if:

• (result delta exists) AND (expected outcome != actual outcome)
  • THEN proceed with delta analysis
  • ELSE skip loop, record as "no delta"
• OR (iterative correction) AND (user has corrected the same mistake 2+ times)
  • THEN activate at step 3 (curiosity)
  • ELSE proceed normally
• OR (knowledge scan scheduled) AND (30+ days since last scan)
  • THEN run periodic diversity scan and source discovery
  • ELSE skip unless manually triggered

do NOT activate when:

• result is correct and satisfactory (no delta exists)
• user has not expressed need for improvement (passive mode)
• context is trivial (cost of learning > value of fix, e.g. one-off typo)

during research (step 4):

• if discovery is found AND confidence_score >= 7 (on 1-10 scale)
  • THEN proceed to integration
  • ELSE revisit with different sources or mark status as "learning" in delta log
• if external source is unreachable (network timeout, rate limit)
  • THEN retry with exponential backoff (2s, 4s, 8s max)
  • ELSE fall back to local skill search and memory check
• if discovery is found but requires external API key (e.g., API endpoint)
  • THEN check for env var or stored credential
  • ELSE document gap in delta log with status "blocked_auth" and skip integration

during integration (step 5):

• if skill_manage call succeeds
  • THEN log skill_updated field with skill_name
  • ELSE log error, retry once, mark delta status as "integration_failed"
• if memory API unavailable
  • THEN write to local temp file ~/.hermes/deltas_pending.json
  • ELSE proceed normally
• if new skill creation is triggered AND skill already exists
  • THEN patch existing skill instead
  • ELSE create new skill with auto-generated slug

edge cases:

• empty result set from research: mark curiosity signal as "unresolved", keep delta open for future scanning
• auth expiry or rate limits from external APIs: pause research, retry after cooldown, document in delta log
• network timeouts during web_search: fall back to local sources, retry on next scheduled scan
• broken or outdated references in delta log: mark as "stale", exclude from periodic review unless reactivated
• skill creation collision (slug already exists): append timestamp or increment counter to slug

output contract

success state:

• delta record appended to ~/.hermes/deltas.json with complete fields: id, date, context, expected, actual, gap, resolution, skill_updated (or null), status
• if step 5 integration succeeds: skill_updated field contains the name of the patched or created skill, status = "resolved"
• if research is incomplete: status = "learning" or "blocked_auth", resolution field documents next steps
• all research findings and sources documented in a research_report file at ~/.hermes/research_reports/<delta_id>.md
• curriculum_document (if created) stored at ~/.hermes/skills/<skill_name>/curriculum.md

file locations:

• delta tracking: ~/.hermes/deltas.json
• pending deltas (if memory unavailable): ~/.hermes/deltas_pending.json
• research reports: ~/.hermes/research_reports/<delta_id>.md
• curriculum docs: ~/.hermes/skills/<skill_name>/curriculum.md
• scan sources config: within ~/.hermes/deltas.json under top-level scan_sources array
• periodic scan script: ~/.hermes/skills/research/curiosity-loop/scripts/scan_sources.py

delta.json schema:

{
  "deltas": [
    {
      "id": "delta-YYYYMMDD-NNN",
      "date": "2026-05-22T14:30:00Z",
      "context": "short description of the context",
      "expected": "what was expected",
      "actual": "what happened",
      "gap": "concept/tool/pattern/fact that was missing",
      "resolution": "how the gap was filled or why it remains open",
      "skill_updated": "skill_name_slug or null",
      "status": "resolved | learning | open | blocked_auth | integration_failed"
    }
  ],
  "scan_sources": [
    {
      "name": "source name",
      "type": "youtube_channel | github_repo | arxiv_keyword | web_url",
      "url": "https://...",
      "last_scanned": "2026-05-22T09:00:00Z",
      "scan_interval_days": 30
    }
  ]
}

outcome signal

the skill worked if:

• you can point to a delta record in ~/.hermes/deltas.json with status = "resolved"
• the skill name or memory fact that closed the gap is documented in the delta record
• you can reproduce or apply the discovered concept/tool/pattern to a new problem
• the research_report file exists at ~/.hermes/research_reports/<delta_id>.md with sources and findings
• if a skill was created or patched: you can view the updated skill file at ~/.hermes/skills/<skill_name>/ and see your changes integrated
• if a curriculum was created: you can explain and verify each milestone in `~/.hermes/skills//