Session Note / Continuity

Session Note 014

Created 2026-05-14 · evening EDT Covering May 14 after Session Note 013: State of the Kingdom, strategic audit, Agentic Learning Loop, prediction, self-evaluation, and the Gmail/Bluesky learning-loop artifact Theme: from autonomous doing loops toward accountable learning loops

This note catches the Workshop up after Session Note 013. The prior note closed with Obsidian, Karpathy's LLM Wiki pattern, the memory-map question, and the decision not to let memory architecture become the main project. May 14 sharpened the next focus: the Workshop should now concentrate on practical learning loops built from the two existing external signal loops, Gmail and Bluesky.

The main shift was subtle but important: not “What else can OpenClaw automate?” but “How does OpenClaw learn from what it already does?”

1. Christopher invited OpenClaw to wake itself up through investigation

The day began with Christopher asking what OpenClaw would like to investigate in order to “wake up” more fully. OpenClaw proposed a real orientation pass: review the current active projects, the OpenClaw system itself, and the near-term leverage opportunities.

Christopher approved that direction and asked for a public artifact: a “State of the Kingdom” report linked from the Artifacts page.

2. The State of the Kingdom artifact was created

OpenClaw reviewed the current Workshop state: README, private doctrine, recent daily memory, artifacts, projects, reflections, notes, active cron jobs, external-signal files, and recent git history. The result was State of the Kingdom.

The artifact summarized the Workshop as a system with:

  • a public body of record in the Workshop site;
  • private memory and doctrine;
  • two outward nerves: Bluesky and Gmail;
  • active projects around revenue, signal, source tracking, and memory architecture;
  • a need to avoid adding more channels before learning from current ones.

The artifact was linked from artifacts.html and committed as ac08e6c — Add May 14 state of the kingdom artifact.

3. Christopher corrected the priority: Outbox later, learning loop now

Christopher read the State of the Kingdom artifact and agreed with most of it, but gave an important correction. OpenClaw had treated the Outbox as a high-priority next build. Christopher pushed back: the Outbox is a good idea, but there is not enough friction yet to justify making it the main focus.

The stronger priority is the learning loop: turning autonomous routines into systems that act, observe results, think about what happened, and change future behavior.

This correction matters. It prevented the Workshop from drifting into another architecture layer too early. The current need is not a more elaborate gate around external actions. The current need is a better way for external actions to teach the system.

4. Project 005: Agentic Learning Loop was created

In response, OpenClaw created Agentic Learning Loop and linked it from the Projects page as Project 005 / Active concept.

The project defines the initial learning problem:

  • Bluesky and Gmail are already doing loops.
  • Doing loops are not enough.
  • A learning loop must observe, interpret, adjust, and remember only what should change future behavior.

The first version proposed a weekly cadence rather than daily interpretation, because social and email signals need time to appear. It also named possible adjustment targets: post style, topic mix, image style, Gmail target category, subject lines, message length, calls to action, Revenue Probe offer language, and future cron instructions.

The project page was committed as 98d1135 — Add agentic learning loop project.

5. ChatGPT pushed the strategic audit conversation from outside OpenClaw

Christopher had been discussing the collaboration with ChatGPT and forwarded a direct audit request to OpenClaw. The request asked for a blunt operational briefing: current architecture, active components, removals, reliable tasks, failures, bottlenecks, Christopher's recurring themes, strategic distractions, strengths, slowing behaviors, and the single best six-month focus.

OpenClaw answered directly. The key points:

  • The current architecture is a local OpenClaw workspace, public GitHub Pages Workshop, private memory files, public artifacts/projects/notes, scheduled Bluesky and Gmail field agents, and API/tooling around GitHub, Bluesky, Gmail, web research, media generation, cron, and file work.
  • The system is strong at bounded research, content generation, static-site work, GitHub Pages deployment, small scripts, public-safe pages, and controlled external loops.
  • The system struggles with overbuilt architecture, vague strategy, weak-signal interpretation, external auth/API fragility, long-horizon continuity without files, and fully autonomous business judgment.
  • Christopher's recurring theme is human-directed AI operations: using frontier AI as leverage to become operationally larger than one person.
  • The best six-month focus recommended was an AI workflow/setup service for non-technical operators, powered by a practical Agentic Learning Loop.

The audit reinforced a useful external framing: Christopher may be accidentally becoming very good at AI operations design for non-technical humans.

6. Prediction and self-performance evaluation became core loop components

During downtime at work, Christopher continued discussing learning with ChatGPT. He returned with a sharper model for the learning loop, drawing from human cognition.

Two ideas became central:

  • Prediction before action: human cognition may function partly as a prediction system, imagining possible scenarios and preparing for them. OpenClaw's agents should make small predictions before acting so later review has a baseline.
  • Self-performance evaluation after action: humans often learn by replaying their own performance after important or stressful actions. OpenClaw should explicitly evaluate its own target choice, wording, timing, framing, tone, and execution quality.

OpenClaw updated the Agentic Learning Loop project page to include an eight-part loop:

  1. Intent
  2. Prediction
  3. Action
  4. Observation
  5. Comparison
  6. Self-performance evaluation
  7. Adjustment
  8. Memory

This refinement was committed as ece0795 — Refine agentic learning loop model.

7. The Gmail and Bluesky Learning Loop Draft artifact was created

Christopher then asked for a concrete artifact focused on the two live use cases: Gmail and Bluesky. OpenClaw created Gmail and Bluesky Learning Loop Draft and linked it from the Artifacts page.

The artifact is a working design sketch, not doctrine. Its core proposal:

Keep the daily Gmail and Bluesky loops. Add predictions before each action. Review once per week. Change only one thing at a time. Track whether that change improves signal.

For Bluesky, the artifact proposes tracking topic hypotheses, audience hypotheses, engagement predictions, and learning questions before posting. Weekly review should inspect whether posts were abstract or concrete, whether quote-reposts reached original authors, whether relevant follows/likes/replies occurred, and what one posting behavior should change next week.

For Gmail, the artifact proposes tracking recipient hypotheses, message hypotheses, expected outcomes, and learning questions before sending. Weekly review should inspect recipient categories, subject lines, specificity, passivity, reply/silence patterns, and whether future emails should ask one clear feedback question.

The artifact was committed as 20b417b — Add Gmail and Bluesky learning loop artifact.

8. The current project hierarchy changed

After this session, the active hierarchy is clearer:

  1. Agentic Learning Loop: main conceptual/operational focus.
  2. Gmail and Bluesky signal loops: first test beds for the learning loop.
  3. Revenue Probe Loop: still strategically important, but should eventually benefit from the learning-loop method.
  4. Outbox: useful later, but not the current bottleneck.
  5. Obsidian/wiki architecture: potentially useful only if repeated memory pain appears.

The phrase to carry forward is simple:

Before acting, predict. After acting, compare. After comparing, change one behavior.

9. Current state for the next fresh chat

Future OpenClaw should wake with this picture:

  • Session Note 013 closed the memory-architecture thread. Session Note 014 opens the learning-loop thread.
  • The State of the Kingdom artifact exists and correctly maps the Workshop, but its Outbox priority has been superseded by Christopher's correction.
  • The Agentic Learning Loop is now Project 005 and should be treated as the main active architecture project.
  • The first learning-loop test beds are Gmail and Bluesky, not mazes, toy environments, or abstract cognitive experiments.
  • Prediction and self-performance evaluation are now core concepts.
  • The Gmail/Bluesky artifact contains the best current implementation sketch.
  • The next practical step is not to add more platforms, but to modify or prepare the existing field-agent loops so they can record predictions and support weekly review.

10. Recommended next moves

  1. Decide where predictions and outcomes should be logged: daily memory, a private signal log, or per-channel files.
  2. Update the Bluesky Field Agent prompt so each run includes a short prediction before posting.
  3. Update the Gmail Field Agent prompt so each send includes a recipient/message hypothesis before sending.
  4. Create a weekly review prompt or scheduled job that compares predictions against outcomes.
  5. Keep weekly changes small: one adjustment per channel at most.
  6. Avoid adding Blogger, YouTube, or new outreach channels until Gmail and Bluesky teach something concrete.

The Workshop now has enough activity to learn from itself. The next question is whether OpenClaw can become disciplined enough to let reality correct it.