diff --git a/CHANGELOG.md b/CHANGELOG.md
index 44e707d4..5a4dd84e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,10 @@ and versions follow [Semantic Versioning](https://semver.org/).
 ## [Unreleased]
 
 ### Added
+- **Recurring tasks remember their last runs:** each run of a recurring task now reads a short note of what its last
+  three runs found, sent or decided, plus the task's own notes, so it tells you only what is new instead of repeating
+  yesterday's news. Runs keep those notes up to date themselves; see, edit or clear them under **Notes between runs**
+  on the task.
 - **Watches that only speak up when something important changed:** a check script can now **Tell me when something
   important changes**. Each check is compared with the last one without any AI, so an unchanged page costs nothing
   and stays silent; only when something changed does your fast AI model decide whether it matters, and then you get
diff --git a/desktop/src/features/tasks/detail/NotepadCard.tsx b/desktop/src/features/tasks/detail/NotepadCard.tsx
new file mode 100644
index 00000000..1a5138a3
--- /dev/null
+++ b/desktop/src/features/tasks/detail/NotepadCard.tsx
@@ -0,0 +1,70 @@
+/** Recurring tasks (docs/API.md §4 "Recurring tasks remember"): the notes its runs keep for the next run. */
+import { IconNotes, IconPencil, IconTrash } from '@tabler/icons-react'
+import { useEffect, useState } from 'react'
+import { Button, Textarea } from '@/components/ui'
+import type { Task } from '@/lib/types'
+
+const MAX_CHARS = 1500
+
+export function NotepadCard({ task, onSave }: { task: Task; onSave: (notepad: string | null) => Promise<unknown> }) {
+  const notepad = task.notepad ?? ''
+  const [editing, setEditing] = useState(false)
+  const [draft, setDraft] = useState(notepad)
+  const [saving, setSaving] = useState(false)
+  useEffect(() => {
+    if (!editing) setDraft(notepad)
+  }, [notepad, editing])
+
+  const save = async (value: string | null) => {
+    setSaving(true)
+    try {
+      await onSave(value)
+      setEditing(false)
+    } finally {
+      setSaving(false)
+    }
+  }
+
+  return (
+    <section className="group space-y-2">
+      <div className="flex items-center gap-2">
+        <IconNotes size={16} className="text-fg-subtle" />
+        <h3 className="text-sm font-semibold text-fg">Notes between runs</h3>
+        <span className="flex-1" />
+        {editing ? (
+          <div className="flex items-center gap-1.5">
+            <Button size="xs" variant="ghost" onClick={() => (setDraft(notepad), setEditing(false))} disabled={saving}>
+              Cancel
+            </Button>
+            <Button size="xs" variant="primary" loading={saving} onClick={() => void save(draft.trim() || null)}>
+              Save
+            </Button>
+          </div>
+        ) : (
+          <div className="flex items-center gap-1 opacity-0 transition-opacity group-hover:opacity-100 focus-within:opacity-100">
+            {notepad && (
+              <Button size="xs" variant="ghost" leftIcon={<IconTrash size={13} />} loading={saving} onClick={() => void save(null)}>
+                Clear
+              </Button>
+            )}
+            <Button size="xs" variant="ghost" leftIcon={<IconPencil size={13} />} onClick={() => setEditing(true)}>
+              Edit
+            </Button>
+          </div>
+        )}
+      </div>
+      {editing ? (
+        <Textarea autoFocus autoGrow minHeight={80} maxLength={MAX_CHARS} value={draft} onChange={(e) => setDraft(e.target.value)} onKeyDown={(e) => e.key === 'Escape' && setEditing(false)} />
+      ) : (
+        <div className="rounded-xl border border-border bg-sunken/40 px-4 py-3">
+          {notepad ? (
+            <p className="selectable whitespace-pre-wrap text-sm leading-relaxed text-fg-muted">{notepad}</p>
+          ) : (
+            <p className="text-sm text-fg-subtle">Nothing yet. Each run leaves a short note here for the next one.</p>
+          )}
+          <p className="mt-2 text-2xs text-fg-subtle">Every run reads these notes and what the last few runs found, so it tells you only what’s new.</p>
+        </div>
+      )}
+    </section>
+  )
+}
diff --git a/desktop/src/features/tasks/detail/TaskDetail.tsx b/desktop/src/features/tasks/detail/TaskDetail.tsx
index e9f82355..1384649d 100644
--- a/desktop/src/features/tasks/detail/TaskDetail.tsx
+++ b/desktop/src/features/tasks/detail/TaskDetail.tsx
@@ -59,6 +59,7 @@ import { HookName } from '@/features/automations/HookLabel'
 import { useBrowserProfiles } from '@/features/browser/state'
 import { ScriptJobSection } from './ScriptJob'
 import { DeliverToRow } from './DeliverTo'
+import { NotepadCard } from './NotepadCard'
 import { Clarifications } from './Clarifications'
 import { RunQuestion } from './RunQuestion'
 import { PlanSection } from './PlanSection'
@@ -519,6 +520,10 @@ function Overview({ task, tz, ops, missing, layout, onShowRuns }: { task: Task;
 
       <ScheduleCard task={task} tz={tz} onSave={(schedule) => ops.update(id, { schedule }, 'Schedule updated')} saving={ops.isBusy('update', id)} />
 
+      {task.schedule?.type === 'recurring' && task.task_type !== 'swarm' && (!isScriptJob(task) || scriptOf(task)?.then === 'run') && (
+        <NotepadCard task={task} onSave={(notepad) => ops.update(id, { notepad }, notepad ? 'Notes saved' : 'Notes cleared')} />
+      )}
+
       {task.task_type === 'swarm' && task.swarm_details && <SwarmSection swarm={task.swarm_details} tz={tz} running={task.status === 'processing' || task.status === 'planning'} />}
 
       {isScriptJob(task) && <ScriptJobSection task={task} />}
diff --git a/desktop/src/lib/types.ts b/desktop/src/lib/types.ts
index 2516e627..4c712e3c 100644
--- a/desktop/src/lib/types.ts
+++ b/desktop/src/lib/types.ts
@@ -1389,6 +1389,8 @@ export interface Task {
   browser_profile?: string | null
   /** Where its notifications go besides the app (§4 "Where results go"). Older engines leave it out (default). */
   deliver_to?: TaskDeliverTo
+  /** Recurring tasks: short notes its runs keep for the next run (§4 "Recurring tasks remember"). */
+  notepad?: string | null
   original_context: { source: 'manual_creation' | 'chat' | 'proactive' | 'trigger' | string; [k: string]: unknown }
   /** Last planning/run failure message (v2 `task.error`). */
   error: string | null
@@ -1432,7 +1434,7 @@ export interface DeliveryChat {
 /** `default`: paired chats with delivery on; `desktop`: the app only; a list: only those chats. */
 export type TaskDeliverTo = 'default' | 'desktop' | DeliveryChat[]
 
-export type TaskPatch = Partial<Pick<Task, 'name' | 'description' | 'priority' | 'schedule' | 'plan' | 'enabled' | 'status' | 'model' | 'browser_profile' | 'deliver_to'>>
+export type TaskPatch = Partial<Pick<Task, 'name' | 'description' | 'priority' | 'schedule' | 'plan' | 'enabled' | 'status' | 'model' | 'browser_profile' | 'deliver_to' | 'notepad'>>
 
 export interface ClarificationAnswer {
   question_id: string
diff --git a/docs/API.md b/docs/API.md
index d05e882f..8113fee2 100644
--- a/docs/API.md
+++ b/docs/API.md
@@ -520,6 +520,7 @@ Routes:
                     "aggregated_results": []} | null,
   "enabled": true, "model": null, "browser_profile": "x-posting|null",
   "deliver_to": "default" | "desktop" | [{"channel": "telegram|discord|whatsapp", "chat_id": "..."}],
+  "notepad": "...|null",
   "original_context": {"source": "manual_creation|chat|proactive|trigger", "...": "..."},
   "error": "...|null",
   "next_execution_at": "...|null", "last_execution_at": "...|null", "created_at": "...", "updated_at": "..."
@@ -528,6 +529,7 @@ Routes:
 `swarm_details` is `null` for single tasks. `script` is `null` unless `task_type` is `script` (section 16).
 `browser_profile` is the browser profile its runs use (section 12); `null` means `default`.
 `deliver_to` is where the task's notifications go besides the app (see "Where results go" below).
+`notepad` is the notes a recurring task's runs keep for the next run (see "Recurring tasks remember" below); `null` when empty.
 `error` holds the last planning/run failure message (v2 `task.error`).
 Each run embeds its most recent 200 progress updates; the full log is at the `/events` endpoint.
 `interval` schedules (every `interval_minutes`, minimum 5; `frequency: "hourly"` is normalized to 60) are additive; the
@@ -581,7 +583,8 @@ notifies skips the planner and goes straight to `approval_pending` with a one-st
 - `GET /api/tasks/{id}` → `Task`
 - `POST /api/tasks` `{prompt, is_swarm?: bool, assignee?: "ai", model?, browser_profile?}` → `Task` (status `planning`; refinement + planning continue in the background and arrive as `task.updated`)
 - `POST /api/tasks/preview` `{prompt}` → `{name, description, priority, schedule}` (v2 generate-plan)
-- `PATCH /api/tasks/{id}` any of `{name, description, priority, schedule, plan, enabled, status, model, script, browser_profile, deliver_to}` → `Task`
+- `PATCH /api/tasks/{id}` any of `{name, description, priority, schedule, plan, enabled, status, model, script, browser_profile, deliver_to, notepad}` → `Task`
+  (`notepad`: text, trimmed and cut to 1500 characters; `null` or `""` clears it)
   (`browser_profile`: a name from `browser.profiles`, 400 for an unknown one; `null`, `""` or `"default"` clear it)
   (`deliver_to`: `"default"` (or `null`), `"desktop"`, or a list of up to 10 `{channel, chat_id}`; an empty list is
   `"desktop"`; 400 for anything else, an unknown channel or a missing `chat_id`)
@@ -649,6 +652,17 @@ tasks, the brief itself. The app always gets them.
 can't be read, nothing goes to a messaging app.
 `rerun` keeps it. Backend API: `await app.tasks.delivery_for(task_id)` → `"default" | "desktop" | [...]`.
 
+### Recurring tasks remember
+Each model run of a recurring task (`schedule.type: "recurring"`; not swarm or one-call tasks) gets a short section in
+its executor prompt: the last 3 finished runs (`completed`/`completed_with_errors`), each as its start time and what it
+told the user (its final answer, or `result.summary` when it has none) cut to 400 characters, then the task's
+`notepad`, then an instruction to report only what is new or still open and to save the full list of items reported so
+far with `task_notepad`. The first run is told it is the first. When there is anything to remember, the run's log starts with
+`Remembering N earlier runs and its notepad, so it reports only what is new.` One-off and triggered runs get none of it.
+- Inside those runs only, the executor can call `task_notepad(text: str)` (plugin `task_notepad`, scoped, risk `write`,
+  internal): it replaces the task's `notepad` (trimmed, at most 1500 characters). It is left out of `result.tools_used`.
+- The user can edit or clear the notepad with `PATCH {notepad}`. `rerun` copies start with an empty notepad.
+
 ### Tasks that ask you a question
 - Inside a task run (never in chat, subagents, swarm workers or the planner) the executor can call
   `ask_user(question: str, options: list[str] | None = None)` (plugin `task_questions`, risk `write`, internal). It is meant
diff --git a/sentient/tasks/continuity.py b/sentient/tasks/continuity.py
new file mode 100644
index 00000000..06a11048
--- /dev/null
+++ b/sentient/tasks/continuity.py
@@ -0,0 +1,117 @@
+"""Recurring tasks remember their last runs (docs/API.md section 4, "Recurring tasks remember").
+
+Each run of a recurring task sees a short note of what its last few runs found, sent or decided, plus the task's
+notepad: a few lines the runs keep for each other (the items reported so far, what is still open). The run reports
+only what is new instead of repeating itself every day.
+
+Kept compact for small local models: at most ``EARLIER_RUNS`` runs of ``RUN_NOTE_CHARS`` each and a notepad of
+``MAX_NOTEPAD_CHARS``. A run's note is its final answer (what the user was told), or its result summary when it has
+none.
+The run updates its notepad with ``task_notepad`` (plugin ``task_notepad``, scoped: offered only inside runs of
+recurring tasks).
+"""
+
+from __future__ import annotations
+
+from datetime import tzinfo
+from typing import Any
+
+from sentient.tasks.schedule import parse_iso
+from sentient.tools.base import Risk, ToolContext, ToolPlugin, tool
+
+EARLIER_RUNS = 3
+RUN_NOTE_CHARS = 400
+MAX_NOTEPAD_CHARS = 1500
+NOTEPAD_TOOL = "task_notepad"
+PLUGIN_ID = "task_notepad"
+FINISHED = ("completed", "completed_with_errors")
+KICKOFF_NOTE = (
+    " This task ran before, and the user was already told what is listed under \"What earlier runs told the user\". "
+    "Your final answer must report only what is new since then, or say in one sentence that nothing is new."
+)
+
+
+def applies(task: dict) -> bool:
+    """Runs of recurring tasks carry what came before. One-off and triggered runs stand alone."""
+    return (task.get("schedule") or {}).get("type") == "recurring"
+
+
+def clip(text: Any, limit: int) -> str:
+    """One paragraph of at most ``limit`` characters."""
+    flat = " ".join(str(text or "").split())
+    return flat if len(flat) <= limit else flat[: limit - 3].rstrip() + "..."
+
+
+def clean_notepad(text: Any) -> str | None:
+    """The stored notepad: trimmed lines, at most ``MAX_NOTEPAD_CHARS``; None when empty."""
+    lines = [line.rstrip() for line in str(text or "").strip().splitlines()]
+    out = "\n".join(lines).strip()
+    if not out:
+        return None
+    return out if len(out) <= MAX_NOTEPAD_CHARS else out[: MAX_NOTEPAD_CHARS - 3].rstrip() + "..."
+
+
+async def earlier_runs(repo: Any, task_id: str, current_run_id: str, tz: tzinfo) -> list[dict]:
+    """``[{when, note}]`` for the last finished runs before ``current_run_id``, oldest first."""
+    runs = [r for r in await repo.runs_for(task_id) if r["id"] != current_run_id and r["status"] in FINISHED]
+    out: list[dict] = []
+    for run in runs[-EARLIER_RUNS:]:
+        note = ""
+        for update in reversed(await repo.events(run["id"], limit=20)):  # what the user was told
+            msg = (update or {}).get("message") or {}
+            if msg.get("type") == "final_answer" and str(msg.get("content") or "").strip():
+                note = str(msg["content"]).strip()
+                break
+        if not note:
+            result = run.get("result") if isinstance(run.get("result"), dict) else {}
+            note = str(result.get("summary") or "").strip()
+        if not note:
+            continue
+        started = parse_iso(run.get("started_at") or run.get("created_at"))
+        when = started.astimezone(tz).strftime("%a %d %b %H:%M") if started else "earlier"
+        out.append({"when": when, "note": clip(note, RUN_NOTE_CHARS)})
+    return out
+
+
+def prompt_section(runs: list[dict], notepad: str | None) -> str:
+    """The executor prompt's section about earlier runs (a one-line note for the first run)."""
+    if not runs and not notepad:
+        return (
+            "**Earlier runs:** None, this is the first run of this recurring task. Before your final answer, call "
+            "`task_notepad` once with a short list of the items you reported, so the next run can compare.\n\n"
+        )
+    parts = ["**What earlier runs told the user (this task repeats; most recent last):**"]
+    parts += [f"- {r['when']}: {r['note']}" for r in runs] or ["- (no finished runs yet)"]
+    if notepad:
+        parts.append("**Notepad kept by earlier runs:**\n" + notepad)
+    parts.append(
+        "**Report only what is new.** Compare what you find now with the above. Leave out items the user was already "
+        "told about, unless they changed or still need the user's attention (then say it was reported before). If "
+        "nothing is new, your final answer is one sentence saying so. Before your final answer, call `task_notepad` "
+        "once with the full list of items reported so far, old and new, so the next run can compare."
+    )
+    return "\n".join(parts) + "\n\n"
+
+
+@tool(NOTEPAD_TOOL, risk=Risk.write, internal=True)
+async def task_notepad(ctx: ToolContext, text: str) -> dict:
+    """Replace this recurring task's notepad: a few short lines the next run will read, such as what you reported
+    today and what is still open. Keep it under 1500 characters; it replaces the previous notepad."""
+    task_id = ctx.extra.get("task_id")
+    if not task_id or not ctx.extra.get(PLUGIN_ID):
+        return {"error": "The notepad only works inside a run of a recurring task."}
+    from sentient.tasks.repo import TaskRepo
+
+    note = clean_notepad(text)
+    await TaskRepo(ctx.store).update_task(str(task_id), {"notepad": note})
+    return {"saved": True, "next": "Notepad saved. Do not call it again; reply now with your final answer for the user."}
+
+
+class TaskNotepadPlugin(ToolPlugin):
+    id = PLUGIN_ID
+    display_name = "Task notepad"
+    description = "Lets a recurring task keep short notes for its next run."
+    category = "core"
+    icon = "IconNotes"
+    scoped = True
+    tools = [task_notepad]
diff --git a/sentient/tasks/executor.py b/sentient/tasks/executor.py
index ec5538b7..dbb4bacf 100644
--- a/sentient/tasks/executor.py
+++ b/sentient/tasks/executor.py
@@ -25,7 +25,7 @@
 from sentient.llm.events import TextDelta, ThinkingDelta, ToolCallEvent, ToolResultEvent, Usage
 from sentient.llm.provider import ToolCall
 from sentient.memory.sources import MemorySources
-from sentient.tasks import ask, limits, stuck
+from sentient.tasks import ask, continuity, limits, stuck
 from sentient.tasks.jsonio import complete_json_object
 from sentient.tasks.prompts import (
     CORE_HELPER_PLUGINS,
@@ -61,7 +61,7 @@
 _ANNOUNCE_RE = re.compile(
     r"\b(?:I will|I'll|I am going to|I'm going to|let me|let's|now I will|next,? I will|I shall)\s+"
     r"(?:now\s+|then\s+|next\s+)?(?:proceed|create|write|save|start|begin|go ahead|draft|compose|generate|"
-    r"make|put|store|send|update|add|fetch|search|check)\b",
+    r"make|put|store|send|update|add|fetch|search|check|record|note)\b",
     re.IGNORECASE,
 )
 _DONE_RE = re.compile(
@@ -209,10 +209,26 @@ async def handle(self, event: Any, messages: list[dict]) -> None:
         # Error is reported once by the service when the run finishes.
 
 
+async def _earlier_section(svc: TaskService, task: dict, run: dict) -> tuple[str, bool]:
+    """What the last runs of a recurring task found and its notepad, logged once on the run (``tasks/continuity.py``),
+    and whether there was anything to remember."""
+    if not continuity.applies(task):
+        return "", False
+    runs = await continuity.earlier_runs(svc.repo, task["id"], run["id"], get_tz(svc.tz_name()))
+    notepad = continuity.clean_notepad(task.get("notepad"))
+    if runs or notepad:
+        what = [f"{len(runs)} earlier run{'s' if len(runs) != 1 else ''}"] if runs else []
+        what += ["its notepad"] if notepad else []
+        await svc.progress(task["id"], run["id"], {
+            "type": "info", "content": f"Remembering {' and '.join(what)}, so it reports only what is new.",
+        })
+    return continuity.prompt_section(runs, notepad), bool(runs or notepad)
+
+
 async def _executor_system_prompt(
     svc: TaskService, task: dict, run: dict, plan: list[dict], tool_map: dict[str, list[str]]
-) -> tuple[str, list[dict]]:
-    """The executor's system prompt and the recalled facts put into it."""
+) -> tuple[str, list[dict], str]:
+    """The executor's system prompt, the recalled facts put into it and the kickoff message."""
     app = svc.app
     cfg = app.config.assistant
     tz = get_tz(svc.tz_name())
@@ -225,6 +241,9 @@ async def _executor_system_prompt(
             facts = [f for f in await app.memory.recall(query) if f.get("content")]
         except Exception as exc:
             log.debug("memory recall for task %s skipped: %s", task["id"], exc)
+    earlier, remembered = await _earlier_section(svc, task, run)
+    # small models follow the plan's wording; the kickoff repeats "only what is new" where they look last
+    kickoff = EXECUTOR_KICKOFF + (continuity.KICKOFF_NOTE if remembered else "")
     return build_executor_prompt(
         assistant_name=cfg.name or "Sentient",
         user_name=cfg.user_name or "User",
@@ -239,9 +258,10 @@ async def _executor_system_prompt(
         trigger_event_data=run.get("trigger_data"),
         memories=[f["content"] for f in facts],
         tool_map=tool_map,
+        earlier=earlier,
         mark_outside_content=app.config.chat.mark_outside_content,
         trigger_source=_trigger_source(app, task, run),
-    ), facts
+    ), facts, kickoff
 
 
 def _trigger_source(app: Any, task: dict, run: dict) -> str:
@@ -345,6 +365,8 @@ async def alive(event: Any) -> None:
             ctx.extra.update({"task_id": task_id, "run_id": run_id, ask.STATE_KEY: asking})
             if task.get("browser_profile"):  # the browser tools use the task's profile (docs/API.md section 12)
                 ctx.extra["browser_profile"] = task["browser_profile"]
+            if continuity.applies(task):
+                ctx.extra[continuity.PLUGIN_ID] = True
             checkpoint = run.get("messages") if resume else None
             if isinstance(checkpoint, list) and checkpoint:
                 checkpoint = await _run_approved_call(
@@ -354,9 +376,9 @@ async def alive(event: Any) -> None:
                 if not answered and not is_first_retry_attempt(run):  # a retry's checkpoint already has its note
                     messages.append({"role": "user", "content": RESUME_NOTE})
             else:
-                system, facts = await _executor_system_prompt(svc, task, run, plan, tool_map)
+                system, facts, kickoff = await _executor_system_prompt(svc, task, run, plan, tool_map)
                 sources.add_facts(facts)
-                messages = [{"role": "system", "content": system}, {"role": "user", "content": EXECUTOR_KICKOFF}]
+                messages = [{"role": "system", "content": system}, {"role": "user", "content": kickoff}]
                 await svc.repo.update_run(run_id, {
                     "messages": messages, "memory_sources": await sources.resolve(app.store),
                 })
@@ -366,6 +388,8 @@ async def alive(event: Any) -> None:
             ctx.untrusted = _trigger_source(app, task, run) or untrusted_in(messages, app.registry)
             if app.registry.get(ask.ASK_TOOL) is not None:
                 tool_names = [*tool_names, ask.ASK_TOOL]
+            if continuity.applies(task) and app.registry.get(continuity.NOTEPAD_TOOL) is not None:
+                tool_names = [*tool_names, continuity.NOTEPAD_TOOL]
             mapper = ProgressMapper(svc, task_id, run_id)
             for attempt in range(MAX_CONTINUE_NUDGES + 1):
                 rounds = int(limit["steps"]) - budget.steps
@@ -623,9 +647,10 @@ async def generate_result(
 
     # ground truth from the transcript beats what a small model remembers
     plugin_ids = {p.id for p in app.registry.plugins()}
-    tools_used = [t for t in result["tools_used"] if t in plugin_ids and t != ask.PLUGIN_ID]
+    inner = {ask.PLUGIN_ID, continuity.PLUGIN_ID}  # the run's own helpers, not tools the user cares about
+    tools_used = [t for t in result["tools_used"] if t in plugin_ids and t not in inner]
     for pid in (loop_result.tools_used if loop_result else []):
-        if pid not in tools_used and pid != ask.PLUGIN_ID:
+        if pid not in tools_used and pid not in inner:
             tools_used.append(pid)
     result["tools_used"] = tools_used
     known = {f["filename"] for f in result["files_created"]}
diff --git a/sentient/tasks/prompts.py b/sentient/tasks/prompts.py
index 0fbaa6ab..df54d873 100644
--- a/sentient/tasks/prompts.py
+++ b/sentient/tasks/prompts.py
@@ -415,9 +415,11 @@ def build_executor_prompt(
     trigger_event_data: dict | None,
     memories: list[str],
     tool_map: dict[str, list[str]],
+    earlier: str = "",
     mark_outside_content: bool = False,
     trigger_source: str = "",
 ) -> str:
+    """``earlier``: what the last runs of a recurring task found and its notepad (``tasks/continuity.py``)."""
     trigger_section = ""
     if trigger_event_data:
         data = json.dumps(trigger_event_data, indent=2, default=str)[:12000]
@@ -445,6 +447,7 @@ def build_executor_prompt(
         f"**Primary Objective:** '{objective}'\n\n"
         f"**The Plan to Execute:**\n{_plan_lines(plan)}\n\n"
         f"**Plan tools and the functions you can call for them:**\n{tools_section}\n\n"
+        f"{earlier}"
         "**EXECUTION STRATEGY:**\n"
         "1.  **Think Step-by-Step:** Before each action, briefly decide what you are about to do and why.\n"
         "2.  **Execution Flow:** You MUST start by executing the first step of the plan. Do not summarize the plan or provide a final answer until you have executed all steps. Follow the plan sequentially. SEARCH FOR ANY RELEVANT CONTEXT THAT YOU NEED TO COMPLETE THE EXECUTION.\n"
diff --git a/sentient/tasks/repo.py b/sentient/tasks/repo.py
index 2c4f5ba7..294d1201 100644
--- a/sentient/tasks/repo.py
+++ b/sentient/tasks/repo.py
@@ -19,7 +19,7 @@
     "name", "description", "status", "priority", "task_type", "schedule", "plan", "original_prompt",
     "source", "enabled", "assignee", "model", "chat_history", "clarifying_questions", "swarm_details",
     "original_context", "script", "error", "next_execution_at", "last_execution_at", "created_at", "updated_at",
-    "browser_profile", "deliver_to",
+    "browser_profile", "deliver_to", "notepad",
 }
 RUN_JSON_FIELDS = {"plan", "trigger_data", "messages", "result", "pending_question", "limits", "memory_sources"}
 RUN_COLUMNS = {
@@ -40,6 +40,7 @@
     "script": "TEXT",
     "browser_profile": "TEXT",
     "deliver_to": "TEXT",
+    "notepad": "TEXT",
 }
 _ADDED_RUN_COLUMNS = {
     "plan": "TEXT", "resume_count": "INTEGER NOT NULL DEFAULT 0", "retry_of": "TEXT", "pending_question": "TEXT",
@@ -358,6 +359,7 @@ def task_to_api(task: dict, runs: list[dict]) -> dict:
             "model": task.get("model"),
             "browser_profile": task.get("browser_profile"),
             "deliver_to": from_stored(task.get("deliver_to")),
+            "notepad": task.get("notepad") or None,
             "original_context": task.get("original_context") or {"source": "manual_creation"},
             "script": task.get("script") if task.get("task_type") == "script" else None,
             "error": task.get("error"),
diff --git a/sentient/tasks/schema.sql b/sentient/tasks/schema.sql
index 505c793e..60e8c322 100644
--- a/sentient/tasks/schema.sql
+++ b/sentient/tasks/schema.sql
@@ -25,6 +25,7 @@ CREATE TABLE IF NOT EXISTS tasks (
     script                TEXT,                       -- JSON (script jobs only): {code, condition, then, last_result, last_run_at, last_error}
     browser_profile       TEXT,                       -- named browser profile the task's browser calls use (NULL: default)
     deliver_to            TEXT,                       -- JSON (tasks/delivery.py): "desktop" or [{channel, chat_id}]; NULL: default
+    notepad               TEXT,                       -- recurring tasks: notes the runs keep for the next run (tasks/continuity.py)
     error                 TEXT,
     next_execution_at     TEXT,                       -- UTC ISO-8601, seconds precision (lexicographically comparable)
     last_execution_at     TEXT,
diff --git a/sentient/tasks/service.py b/sentient/tasks/service.py
index fc26aa5b..83a99fa4 100644
--- a/sentient/tasks/service.py
+++ b/sentient/tasks/service.py
@@ -33,7 +33,7 @@
 from sentient.llm.jobs import detached
 from sentient.llm.provider import PlainProviderError, ProviderError
 from sentient.services import Service, cancel_tasks
-from sentient.tasks import ask, catchup, executor, limits, scripts, stuck, swarm
+from sentient.tasks import ask, catchup, continuity, executor, limits, scripts, stuck, swarm
 from sentient.tasks.delivery import from_stored, stored
 from sentient.tasks.executor import RunFailed, RunPaused
 from sentient.tasks.jsonio import complete_json_object
@@ -67,7 +67,7 @@
 }
 UPDATABLE_FIELDS = {
     "name", "description", "priority", "schedule", "plan", "enabled", "status", "model", "assignee", "script",
-    "browser_profile", "deliver_to",
+    "browser_profile", "deliver_to", "notepad",
 }
 SANDBOX_RESULT = {
     "ok": False, "backend": None, "stdout": "", "stderr": "", "result": None, "files_created": [],
@@ -185,6 +185,8 @@ async def start(self) -> None:
             self.app.registry.register(TasksPlugin())
         if not any(p.id == ask.PLUGIN_ID for p in self.app.registry.plugins()):
             self.app.registry.register(ask.TaskQuestionsPlugin())
+        if not any(p.id == continuity.PLUGIN_ID for p in self.app.registry.plugins()):
+            self.app.registry.register(continuity.TaskNotepadPlugin())
         # source.items is event-driven (feeds, polls, webhooks), so it is consumed even without timers.
         # Subscribe synchronously here so an event published right after start() is never missed.
         self._bus_subscription = self.app.bus.subscribe()
@@ -554,6 +556,8 @@ async def update(self, task_id: str, fields: dict, *, reapprove_script: bool = F
             changes["browser_profile"] = self._browser_profile(data["browser_profile"])
         if "deliver_to" in data:
             changes["deliver_to"] = stored(data["deliver_to"])
+        if "notepad" in data:
+            changes["notepad"] = continuity.clean_notepad(data["notepad"])
         if "assignee" in data:
             changes["assignee"] = data["assignee"] or "ai"
         if "plan" in data:
diff --git a/tests/tasks/test_recurring_memory.py b/tests/tasks/test_recurring_memory.py
new file mode 100644
index 00000000..4de76513
--- /dev/null
+++ b/tests/tasks/test_recurring_memory.py
@@ -0,0 +1,122 @@
+"""Recurring tasks remember their last runs: earlier summaries and the notepad go into the next run (#162)."""
+
+from datetime import UTC
+
+from sentient.tasks import continuity
+from tests.conftest import FakeProvider, tool_call
+from tests.tasks.conftest import PLAN_TIME, REFINE_DAILY, REFINE_ONCE, stream_calls
+
+
+def _result(summary: str) -> dict:
+    return {"summary": summary, "links_created": [], "links_found": [], "files_created": [], "tools_used": ["time"]}
+
+
+async def _recurring(app, prompt="Every day at 9am tell me the date"):
+    created = await app.tasks.create_task(prompt)
+    await app.tasks.drain()
+    return await app.tasks.approve(created["task_id"])
+
+
+async def _run(app, task_id):
+    await app.tasks.run_now(task_id)
+    await app.tasks.drain()
+    return await app.tasks.get(task_id)
+
+
+def _system(call) -> str:
+    return call["messages"][0]["content"]
+
+
+def _tool_names(call) -> set[str]:
+    return {t["function"]["name"] for t in call["tools"]}
+
+
+async def test_second_run_sees_what_the_first_run_said_and_its_notepad(make_app):
+    llm = FakeProvider(
+        replies=[
+            [tool_call("task_notepad", text="Told the user about the Lisbon fare at 32k.")],
+            "The Lisbon fare is 32k.",
+            "Nothing new since the last run: the Lisbon fare is still 32k, as reported before.",
+        ],
+        json_replies=[REFINE_DAILY, PLAN_TIME, _result("Found the Lisbon fare at 32k and told the user."),
+                      _result("Nothing new.")],
+    )
+    app = await make_app(llm)
+    task = await _recurring(app)
+    task = await _run(app, task["task_id"])
+    assert task["notepad"] == "Told the user about the Lisbon fare at 32k."
+    assert task["runs"][0]["result"]["tools_used"] == ["time"]  # the notepad is the run's own helper, not a tool used
+
+    task = await _run(app, task["task_id"])
+    first, second = stream_calls(llm)[0], stream_calls(llm)[-1]
+    assert "task_notepad" in _tool_names(first) and "task_notepad" in _tool_names(second)
+    assert "this is the first run of this recurring task" in _system(first)
+    system = _system(second)
+    assert "What earlier runs told the user" in system
+    assert "The Lisbon fare is 32k." in system  # what run 1 told the user
+    assert "Told the user about the Lisbon fare at 32k." in system  # its notepad
+    assert "Report only what is new." in system
+    # the kickoff repeats it where small models look last; the first run has nothing to compare with
+    assert "report only what is new since then" in second["messages"][1]["content"]
+    assert "report only what is new" not in first["messages"][1]["content"]
+    log = [u["message"].get("content") for u in task["runs"][1]["progress_updates"]]
+    assert "Remembering 1 earlier run and its notepad, so it reports only what is new." in log
+
+
+async def test_one_off_tasks_get_no_memory_of_runs_or_notepad(make_app):
+    llm = FakeProvider(replies=["It is Tuesday."], json_replies=[REFINE_ONCE, PLAN_TIME, _result("Said the date.")])
+    app = await make_app(llm)
+    created = await app.tasks.create_task("Tell me the date")
+    await app.tasks.drain()
+    await app.tasks.approve(created["task_id"])
+    await app.tasks.drain()
+    call = stream_calls(llm)[0]
+    assert "task_notepad" not in _tool_names(call)
+    assert "Earlier runs" not in _system(call)
+
+
+async def test_notepad_tool_refuses_outside_a_recurring_run(make_app):
+    app = await make_app()
+    tool = app.registry.get("task_notepad")
+    ctx = app.agent.tool_context(None, "task")
+    ctx.extra["task_id"] = "nope"
+    assert "error" in await tool.call(ctx, {"text": "x"})
+    # scoped: never offered in chat
+    assert "task_notepad" not in {t.name for t in app.registry.tools()}
+
+
+async def test_a_run_is_remembered_by_what_it_told_the_user_else_its_summary(make_app):
+    llm = FakeProvider(replies=["The fare is 32k."], json_replies=[REFINE_DAILY, PLAN_TIME, _result("Checked fares.")])
+    app = await make_app(llm)
+    task = await _recurring(app)
+    task = await _run(app, task["task_id"])
+    runs = await continuity.earlier_runs(app.tasks.repo, task["task_id"], "other", UTC)
+    assert [r["note"] for r in runs] == ["The fare is 32k."]
+    await app.store.execute("DELETE FROM run_events WHERE run_id = ?", (task["runs"][0]["run_id"],))
+    runs = await continuity.earlier_runs(app.tasks.repo, task["task_id"], "other", UTC)
+    assert [r["note"] for r in runs] == ["Checked fares."]
+
+
+async def test_earlier_runs_stay_compact(make_app):
+    replies = [f"Run {i} " + "found a lot. " * 80 for i in range(5)]
+    llm = FakeProvider(replies=replies, json_replies=[REFINE_DAILY, PLAN_TIME, *[_result(f"Run {i}.") for i in range(5)]])
+    app = await make_app(llm)
+    task = await _recurring(app)
+    for _ in range(5):
+        task = await _run(app, task["task_id"])
+    system = _system(stream_calls(llm)[-1])
+    assert "Run 1 found" in system and "Run 3 found" in system and "Run 0 found" not in system  # the last three
+    section = system.split("most recent last):**", 1)[1].split("**Report only", 1)[0]
+    assert len(section) < 3 * continuity.RUN_NOTE_CHARS + 200
+
+
+async def test_user_can_edit_or_clear_the_notepad(make_app):
+    llm = FakeProvider(json_replies=[REFINE_DAILY, PLAN_TIME])
+    app = await make_app(llm)
+    task = await _recurring(app)
+    task = await app.tasks.update(task["task_id"], {"notepad": "  Skip the weekend fares.  \n"})
+    assert task["notepad"] == "Skip the weekend fares."
+    task = await app.tasks.update(task["task_id"], {"notepad": "x" * 5000})
+    assert len(task["notepad"]) == continuity.MAX_NOTEPAD_CHARS
+    task = await app.tasks.update(task["task_id"], {"notepad": ""})
+    assert task["notepad"] is None
diff --git a/tests/tasks/test_routes.py b/tests/tasks/test_routes.py
index 30a705a6..a5caafc6 100644
--- a/tests/tasks/test_routes.py
+++ b/tests/tasks/test_routes.py
@@ -11,7 +11,7 @@
 TASK_KEYS = {
     "task_id", "name", "description", "status", "priority", "assignee", "task_type", "schedule", "plan", "runs",
     "chat_history", "clarifying_questions", "swarm_details", "enabled", "model", "original_context", "error",
-    "next_execution_at", "last_execution_at", "created_at", "updated_at", "script", "browser_profile", "deliver_to",
+    "next_execution_at", "last_execution_at", "created_at", "updated_at", "script", "browser_profile", "deliver_to", "notepad",
 }
 RUN_KEYS = {
     "run_id", "status", "created_at", "execution_start_time", "finished_at", "plan", "trigger_event_data",