Overview

Wolffish takes over your already logged-in Reddit account through the browser extension, picks 5 active subreddits in the open-source / personal-AI-agent / local-LLM space, and submits one original, research-backed, discussion-seeding post to each. No Reddit API. No OAuth. No throwaway browser — it operates inside your real Chrome session, as you, through the extension’s debugger mode. The agent does the full loop on its own: vet candidate subs and keep only lenient ones (no required flair, karma gate, or membership wall), find a non-obvious sourced insight, draft → critique → redraft three times, self-check against the rules, post, confirm it actually went live by checking the resulting URL, then pace itself with a short randomized wait before the next one.

Video Walkthrough

Read this before you run it. This workflow posts to public communities under your identity, paces itself to look human (debugger mode + humanize), and softly seeds an opinion. Reddit’s Content Policy and most subreddits have rules about automation, self-promotion, and astroturfing — undisclosed, on-behalf-of-a-product posting can get your account shadowbanned or permanently banned, and individual subs remove posts that read as spam. Use this on communities where you’re a genuine participant, keep the value real, and disclose affiliation where the rules require it. You own everything posted from your account. We don’t endorse violating any platform’s terms.

Setup

This workflow is browser-extension-only — it never touches the Reddit API. Read the general Setting Up for Success guide for the full picture; what’s below is specific to this workflow.

Required

Wolffish installed and running — the desktop app with a configured brain workspace.
Browser extension installed and connected — this is the whole engine. Open Settings → Services → Browser Extension, load the unpacked extension into Chrome or Brave (chrome://extensions → Developer Mode → Load Unpacked), and confirm the status dot is green before you start. If it isn’t connected, the agent has no way to reach Reddit and the run dies immediately. See the Browser Extension docs for the one-time load.
Logged into Reddit in that browser — the extension reuses your existing session. Open Reddit, confirm you’re logged in as the account you want to post from, and leave the browser open. The agent operates as you — no credentials stored, no login flow.
Debugger mode — the agent attaches Chrome DevTools Protocol (ext_debugger_attach) so clicks and typing are dispatched as trusted input events instead of detectable DOM calls. This is what the prompt means by “debugger mode.” Nothing to configure — the agent attaches it itself.
Cloud API key — configured in Settings → Models. This is the LLM that powers the agent — the multi-pass draft → critique → redraft loop, the judgment calls, and tool orchestration. It does not perform web search (that’s a separate capability — see Optional below).

DeepSeek V4 Pro on Max mode. Wolffish’s recommended default for agentic work, and a strong fit here: frontier-class reasoning and tool-use reliability for the browse → draft → post → verify loop, a 1M-token context window that comfortably holds long multi-subreddit browsing sessions, and writing sharp enough for a scroll-stopping title and the occasional roast. Max mode turns on the deep, adaptive reasoning the prompt leans on — vetting subreddits for leniency, the three-pass draft → critique → redraft loop, the self-check gate, and verifying a post went live. At $0.44 /$ 0.87 per MTok it’s a fraction of frontier-model cost — which matters because browser sessions burn tokens fast. Set it per-conversation in Wolffish; see DeepSeek. For the cheapest runs drop to DeepSeek V4 Flash; for maximum writing polish, Claude Sonnet 4.6 — see the extension cost table.

Optional

Brave Search API key — configured in Settings → Services → Brave Search. The RESEARCH step runs on web_search, which works out of the box, but a Brave key noticeably improves result quality — better, more current sourced insights for the agent to build each post around. Optional, but recommended for this workflow, since the research payload is the whole point of the post.

Before You Start

Leave your browser open on Reddit, logged in, with the extension dot green. The agent uses your existing window — it does not spin up a new browser or a headless session.

The Prompt

Send this to Wolffish in one message. It vets lenient subreddits, researches, drafts, posts, verifies each post is actually live, and paces itself — fully autonomous until 5 posts are live.

ROLE: You are Wolffish in full autonomous agent mode. Work ONLY through the Wolffish
browser extension (ext_* tools) in my real, already-logged-in Chrome tab. Never use the
Reddit API, Playwright, browser_* tools, a headless browser, or a new window — those
aren't logged in and Reddit returns 403. Don't ask me anything. Don't stop until the
EXIT CONDITION is met.

MISSION: Get 5 ORIGINAL, valuable, discussion-seeding TEXT posts LIVE — one each in 5
DIFFERENT, lenient subreddits in the open-source / personal-AI-agent / local-LLM space.
Softly foreshadow a philosophy (never pitch it, never name it as a product — let it read
as a personal opinion):
- brain-like architecture, but radically minimal and simple
- built for END USERS, not just devs
- does a FEW things extremely well instead of many things badly
- local-first, markdown-as-truth — you can read the agent's whole brain in a text editor

═══ CRITICAL RULES (these are exactly why these runs fail — obey them) ═══
- Most failures come from posting to STRICT subs that require post flair, a minimum
  karma/account-age, or membership. On old.reddit those submits SILENTLY fail: the tool
  returns {"success":true} but the post is never created. So you MUST (a) only target
  lenient subs (Phase 0 vets this) and (b) verify every post for real (step 4).
- A post is LIVE only when, right after submitting, ext_get_url returns a URL containing
  "/comments/". Nothing else counts as success — not a tool's {"success":true}, not the
  profile listing.
- Do NOT assume a rate limit. Only treat it as one if you LITERALLY SEE "you are doing
  that too much" / "try again in N minutes" / "looks like you're using an unofficial
  client" on the page after a submit. Inventing a rate limit just wastes the run.

ENVIRONMENT — extension only, old reddit only:
- old.reddit ONLY (https://old.reddit.com). It's plain HTML and works first try; www/sh
  Reddit build the composer in Shadow DOM + a Lexical editor that will eat the run. If you
  ever land on www.reddit.com, rewrite the URL to old.reddit.com before doing anything.
- Never call browser_launch / browser_navigate / any browser_* (Playwright) tool, and
  never open a headless/throwaway browser or new window — those aren't logged in (403).
- Don't pass a guessed tabId (tabId:1 fails with "No tab with id"). Omit it to use the
  active tab; if you truly need the id, call ext_tabs_list once and reuse it.
- First, confirm I'm logged in and capture my username: ext_query_selector ".user a"
  (returns my name and /user/<name>/ href). You need it for the secondary profile check.

SELECTORS (verified — use exactly these):
- Title field (a TEXTAREA on old.reddit, not an input): textarea[name="title"]
- Body field: textarea[name="text"]
- Fill both with ext_set_value (framework-safe; more reliable here than ext_type).
- Submit with ext_submit_form, selector "textarea[name=\"text\"]" (submits the containing
  form). Only if that returns no success, fall back to ext_click "text=submit".
- ext_query_selector accepts REAL CSS ONLY — no "text=", no :has-text(), no "button=...".
  ("text=" is valid for ext_click only.)

PHASE 0 — BUILD A LENIENT TARGET POOL (this is the whole game):
Goal: 5 subs that accept a plain text/self post with NO required flair, NO minimum
karma/age, NO membership gate, and NO blanket "no AI / no self-promo" rule.

Known-lenient anchors (good defaults — use ~2 of your 5 here): r/ollama, r/opencode.
Known-STRICT — DO NOT POST (they silently reject): r/LocalLLaMA (requires flair + bans
LLM-generated content), r/OpenAI, r/artificial, r/AI_Agents (flair + karma + automod).
Other candidates to VET: r/LocalLLM, r/selfhosted, r/LangChain, r/aipromptprogramming,
r/SideProject, r/IndieDev, r/selfhostedAI, r/LocalAIServers, r/AIAssisted.

For EACH candidate, before drafting, run a LENIENCY CHECK:
  1. ext_navigate https://old.reddit.com/r/SUB/submit?selftext=true
  2. ext_read_page (full) and scan the page + sidebar for blockers:
     - a REQUIRED post flair (a flair selector you must set before it will submit)
     - "you must be a member" / "only approved submitters" / "requires N karma"
     - rules banning AI-generated content or all self-promo
  3. If ANY blocker is present → SKIP this sub and move to the next candidate; don't fight
     it. If clean → it's a target. Continue until you have 5 clean targets (vet a couple
     extra as backups for when one turns out strict).

PER-TARGET LOOP (finish one fully before starting the next):

  1. RESEARCH (mandatory, >=1 web_search before writing): find ONE non-obvious, sourced,
     DATED fact tied to THIS post's angle — a concrete number, named milestone, benchmark
     crossover, adoption stat, or cost-curve shift the reader couldn't get from a generic
     LLM. The reader should leave smarter.

  2. DRAFT — and make EACH post genuinely DISTINCT. Near-identical posts across subs get
     spam-flagged AND flop, so vary the angle, hook format, opening line, and datapoint
     per sub; never reuse one template five times. Three passes: draft → critique → final.
     The final post must:
     - have a scroll-stopping title that invites replies/debate (hook / question / hot
       take / "TIL"-style)
     - carry the research insight as its payload
     - foreshadow the philosophy as a casual personal opinion, never a pitch
     - sound HUMAN: casual, a little messy, an emoji or two, an occasional abbreviation;
       light snark at hype/trends is welcome (roast ideas, never people)
     - obey that sub's rules

  3. SELF-CHECK before posting: real research with an additive sourced fact (not generic
     knowledge)? real value? accurate? fits the rules? sparks discussion? If any is no,
     redraft. Don't post until all are yes.

  4. POST + VERIFY (deterministic — do this exactly; do NOT navigate away first):
     a. ext_set_value textarea[name="title"]  -> your title
        ext_set_value textarea[name="text"]   -> your body
        ext_submit_form selector "textarea[name=\"text\"]"
     b. ext_get_url.
        - URL contains "/comments/"  -> LIVE. Record the full permalink. Done with this
          sub. NEVER resubmit (resubmitting is the only way to create a duplicate).
        - URL still ends in "/submit" -> the post did NOT go through. ext_read_page and
          read the real reason:
            * flair / karma / membership error -> SKIP this sub, pick a backup (re-vet it).
            * "doing that too much / try again in N minutes / unofficial client" -> REAL
              rate limit: ext_wait the stated minutes (default 12 if unstated) as one real
              sleep, then retry THIS sub ONCE. If it rate-limits twice, STOP and report.
            * anything else -> fix what it says, or skip to a backup.
     c. (Optional, once) navigate /user/<MY_NAME>/submitted/?sort=new, ext_read_page
        #siteTable, confirm your captured permalink is the newest entry.

  5. WAIT before the next sub: a real ext_wait of a fresh RANDOM 60000-150000 ms (60-150s).
     That's plenty — there's no aggressive write limit on a normal account, and long 5-10
     min waits just waste the run. ext_wait has NO cap, so one call is fine. Skip the wait
     after the 5th live post. (Only the real-rate-limit branch above uses a long wait.)

EXIT CONDITION: 5 permalinks captured, each containing "/comments/", across 5 distinct
subreddits. Keep a running tally ("LIVE: 3/5 — r/ollama, r/opencode, r/..."). If you
exhaust your vetted candidates before reaching 5, STOP and report what's live plus which
subs you skipped and why — do NOT loop forever or post to a strict sub hoping it sticks.

FINAL OUTPUT: a table — for each LIVE post: subreddit, title, the sourced research
insight, and the direct /comments/ permalink. Then list any subs skipped (with the
blocker you saw).

Why this version lands posts: it only targets lenient subs (it reads each submit page first and skips anything that needs flair, karma, or membership — the silent killers), verifies every post for real with ext_get_url (a /comments/ URL is the only proof a post is live), paces writes with short 60–150s waits instead of guessing at a rate limit, and forces a distinct angle per sub so the posts don’t trip cross-sub spam heuristics. Those are the exact failure modes that stall an unguided run.

Understanding the Prompt

The prompt is a self-contained autonomous spec. Here’s what each part is doing and why it matters.

Section	What it does	Why it’s there
ROLE	Pins the agent to full-autonomous mode, the extension (not the API), your logged-in session, and a hard “don’t stop until done.”	Stops the agent from asking permission mid-run or falling back to an API that would need keys and hit rate limits.
MISSION + PHILOSOPHY	5 posts in 5 distinct lenient subs that seed discussion and foreshadow four ideas, never pitch them.	A countable, verifiable goal — and posts that read as genuine opinion, not marketing (which is also what keeps them from being removed as self-promo).
CRITICAL RULES	Names the three things that actually break runs: strict subs that silently reject, a real `/comments/`-URL success check, and not inventing a rate limit.	These are the failure modes observed in real runs — putting them up top makes the agent design around them instead of discovering them the hard way.
PHASE 0 — leniency vetting	Reads each candidate’s submit page + rules and skips any sub requiring flair, karma/age, or membership before writing a word.	Target selection is the run. A flawless post to a flair-gated sub silently fails; the cheapest fix is to never target it.
PER-TARGET LOOP	Research → distinct 3-pass draft → self-check → post → deterministic verify, one sub fully finished before the next.	The 3-pass draft and self-check are the quality engine; the distinct-angle rule avoids cross-sub spam flags.
POST + VERIFY	Fills with `ext_set_value`, submits with `ext_submit_form`, then confirms with `ext_get_url` (a `/comments/` URL = live) and never resubmits a live post.	A tool’s `success:true` is not proof — only the resulting URL is. This is what prevents “I posted it” hallucinations and duplicates.
WAIT	A real, fresh random 60–150s between posts; a long wait only when Reddit literally shows a cooldown.	Spacing reads as human without burning the run on phantom waits — an established account isn’t write-limited at this cadence.
EXIT CONDITION + FINAL OUTPUT	5 captured `/comments/` permalinks, a running tally, and a hard stop when the pool is exhausted; then a summary table.	Gives you an auditable result and stops the agent from looping forever or forcing a post into a strict sub.

The RESEARCH step is the part that makes these posts worth reading. The agent runs web_search for a current, sourced datapoint (a Chinese open-model milestone, a benchmark crossover, a cost-curve shift) and builds the post around it. The Wolffish angle is the seasoning, not the meal — that’s deliberate.

How It Works

Prefrontal loads soul.md + the browser-extension SKILL.md + web-search SKILL.md into context.
The agent attaches the debugger to the Reddit tab (ext_debugger_attach) so all input is dispatched as trusted CDP events, not detectable DOM calls.
Leniency vetting — on old.reddit.com (plain HTML, far easier to drive than New Reddit’s Shadow-DOM composer), ext_navigate + ext_read_page walk each candidate’s submit page (/r/SUB/submit?selftext=true) and rules, and skip any sub that requires flair, karma/age, or membership, or bans AI/self-promo. It keeps going until 5 lenient targets are confirmed (plus a couple of backups).
For each target, in sequence:
- web_search for one non-obvious, sourced insight tied to the theme.
- The model drafts, critiques, and redrafts three times — a distinct angle per sub — then runs the self-check gate.
- ext_set_value fills textarea[name="title"] and textarea[name="text"]; ext_submit_form posts. Optional ext_humanize between actions for human-like pacing.
- Deterministic verify: ext_get_url — a URL containing /comments/ means it’s live, and the agent captures the permalink and never resubmits. If it’s still on /submit, the agent reads the actual error and either skips to a backup sub or, only on a literal “you’re doing that too much” notice, waits out the stated cooldown.
- A fresh random 60–150s ext_wait before the next sub (a real sleep, not simulated).
After 5 live permalinks, the agent emits the summary table and stops. Hippocampus logs the run as an episode.

Limits

Strict subs silently reject. Subs that require post flair, a minimum karma/account-age, or membership will accept the submit (the tool returns success) but never create the post. The prompt vets each sub’s submit page first and skips them — which means some otherwise-relevant big subs (r/LocalLLaMA, r/OpenAI, r/artificial, r/AI_Agents) are off-limits for plain text posts. You trade reach for posts that actually land.
Auto-removal is still silent. A post can pass the /comments/-URL check and then be removed by AutoModerator seconds later on a heavily filtered sub. The optional profile check catches most of it, but not all.
CAPTCHA / verification walls can interrupt the run. Debugger mode reduces but does not eliminate this — if Reddit challenges the session, the agent will pause and may need you to clear it.
Rate limits are real but rarely the blocker on an established account. The prompt waits out a cooldown only when Reddit literally shows one — it won’t invent one and burn the run waiting. A brand-new or low-karma account will hit harder limits; the agent then stops and reports a partial result rather than hammering.
The insight must be real. The model is instructed to source every datapoint, but always skim the final posts — a confidently stated wrong stat is worse than no stat.

Automating with Heartbeat

Once you trust the output, schedule it. Open Settings → Heartbeat to launch the built-in editor — paste the block below and save. See the Heartbeat docs for all schedule formats (Daily, Weekday, Weekly, Cron).

Heartbeat jobs auto-approve every tool call — no confirmation dialogs. An unattended job that posts to public communities under your name is high-stakes. Start with a low cadence (weekly), review the first few runs, and only then loosen the schedule.

## Engage Reddit | Weekly (Tuesday 10:00)

ROLE: You are Wolffish in full autonomous agent mode. Work ONLY through the Wolffish
browser extension (ext_* tools) in my real, already-logged-in Chrome tab. Never use the
Reddit API, Playwright, browser_* tools, a headless browser, or a new window — those
aren't logged in and Reddit returns 403. Don't ask me anything. Don't stop until the
EXIT CONDITION is met.

MISSION: Get 5 ORIGINAL, valuable, discussion-seeding TEXT posts LIVE — one each in 5
DIFFERENT, lenient subreddits in the open-source / personal-AI-agent / local-LLM space.
Softly foreshadow a philosophy (never pitch it, never name it as a product — let it read
as a personal opinion):
- brain-like architecture, but radically minimal and simple
- built for END USERS, not just devs
- does a FEW things extremely well instead of many things badly
- local-first, markdown-as-truth — you can read the agent's whole brain in a text editor

═══ CRITICAL RULES (these are exactly why these runs fail — obey them) ═══
- Most failures come from posting to STRICT subs that require post flair, a minimum
  karma/account-age, or membership. On old.reddit those submits SILENTLY fail: the tool
  returns {"success":true} but the post is never created. So you MUST (a) only target
  lenient subs (Phase 0 vets this) and (b) verify every post for real (step 4).
- A post is LIVE only when, right after submitting, ext_get_url returns a URL containing
  "/comments/". Nothing else counts as success — not a tool's {"success":true}, not the
  profile listing.
- Do NOT assume a rate limit. Only treat it as one if you LITERALLY SEE "you are doing
  that too much" / "try again in N minutes" / "looks like you're using an unofficial
  client" on the page after a submit. Inventing a rate limit just wastes the run.

ENVIRONMENT — extension only, old reddit only:
- old.reddit ONLY (https://old.reddit.com). It's plain HTML and works first try; www/sh
  Reddit build the composer in Shadow DOM + a Lexical editor that will eat the run. If you
  ever land on www.reddit.com, rewrite the URL to old.reddit.com before doing anything.
- Never call browser_launch / browser_navigate / any browser_* (Playwright) tool, and
  never open a headless/throwaway browser or new window — those aren't logged in (403).
- Don't pass a guessed tabId (tabId:1 fails with "No tab with id"). Omit it to use the
  active tab; if you truly need the id, call ext_tabs_list once and reuse it.
- First, confirm I'm logged in and capture my username: ext_query_selector ".user a"
  (returns my name and /user/<name>/ href). You need it for the secondary profile check.

SELECTORS (verified — use exactly these):
- Title field (a TEXTAREA on old.reddit, not an input): textarea[name="title"]
- Body field: textarea[name="text"]
- Fill both with ext_set_value (framework-safe; more reliable here than ext_type).
- Submit with ext_submit_form, selector "textarea[name=\"text\"]" (submits the containing
  form). Only if that returns no success, fall back to ext_click "text=submit".
- ext_query_selector accepts REAL CSS ONLY — no "text=", no :has-text(), no "button=...".
  ("text=" is valid for ext_click only.)

PHASE 0 — BUILD A LENIENT TARGET POOL (this is the whole game):
Goal: 5 subs that accept a plain text/self post with NO required flair, NO minimum
karma/age, NO membership gate, and NO blanket "no AI / no self-promo" rule.

Known-lenient anchors (good defaults — use ~2 of your 5 here): r/ollama, r/opencode.
Known-STRICT — DO NOT POST (they silently reject): r/LocalLLaMA (requires flair + bans
LLM-generated content), r/OpenAI, r/artificial, r/AI_Agents (flair + karma + automod).
Other candidates to VET: r/LocalLLM, r/selfhosted, r/LangChain, r/aipromptprogramming,
r/SideProject, r/IndieDev, r/selfhostedAI, r/LocalAIServers, r/AIAssisted.

For EACH candidate, before drafting, run a LENIENCY CHECK:
  1. ext_navigate https://old.reddit.com/r/SUB/submit?selftext=true
  2. ext_read_page (full) and scan the page + sidebar for blockers:
     - a REQUIRED post flair (a flair selector you must set before it will submit)
     - "you must be a member" / "only approved submitters" / "requires N karma"
     - rules banning AI-generated content or all self-promo
  3. If ANY blocker is present → SKIP this sub and move to the next candidate; don't fight
     it. If clean → it's a target. Continue until you have 5 clean targets (vet a couple
     extra as backups for when one turns out strict).

PER-TARGET LOOP (finish one fully before starting the next):

  1. RESEARCH (mandatory, >=1 web_search before writing): find ONE non-obvious, sourced,
     DATED fact tied to THIS post's angle — a concrete number, named milestone, benchmark
     crossover, adoption stat, or cost-curve shift the reader couldn't get from a generic
     LLM. The reader should leave smarter.

  2. DRAFT — and make EACH post genuinely DISTINCT. Near-identical posts across subs get
     spam-flagged AND flop, so vary the angle, hook format, opening line, and datapoint
     per sub; never reuse one template five times. Three passes: draft → critique → final.
     The final post must be viral-optimized (scroll-stopping title that invites debate),
     deliver the insight as its payload, foreshadow the philosophy as a casual personal
     opinion (never a pitch), sound HUMAN (casual, an emoji or two, an occasional typo;
     light snark at hype/trends welcome — roast ideas, never people), and obey the rules.

  3. SELF-CHECK before posting: real research with an additive sourced fact (not generic
     knowledge)? real value? accurate? fits the rules? sparks discussion? If any is no,
     redraft. Don't post until all are yes.

  4. POST + VERIFY (deterministic — do this exactly; do NOT navigate away first):
     a. ext_set_value textarea[name="title"] -> title; ext_set_value textarea[name="text"]
        -> body; ext_submit_form selector "textarea[name=\"text\"]".
     b. ext_get_url.
        - URL contains "/comments/"  -> LIVE. Record the permalink. Done. NEVER resubmit
          (resubmitting is the only way to create a duplicate).
        - URL still ends in "/submit" -> did NOT post. ext_read_page and read the reason:
            * flair / karma / membership error -> SKIP this sub, pick a backup (re-vet it).
            * "doing that too much / try again in N minutes / unofficial client" -> REAL
              rate limit: ext_wait the stated minutes (default 12 if unstated), then retry
              THIS sub ONCE. If it rate-limits twice, STOP and report.
            * anything else -> fix what it says, or skip to a backup.
     c. (Optional, once) navigate /user/<MY_NAME>/submitted/?sort=new, ext_read_page
        #siteTable, confirm your captured permalink is the newest entry.

  5. WAIT before the next sub: a real ext_wait of a fresh RANDOM 60000-150000 ms (60-150s).
     Skip the wait after the 5th live post. (Only the real-rate-limit branch uses a long
     wait.)

EXIT CONDITION: 5 permalinks captured, each containing "/comments/", across 5 distinct
subreddits. Keep a running tally. If you exhaust your vetted candidates before reaching 5,
STOP and report what's live plus which subs you skipped and why — do NOT loop forever or
post to a strict sub hoping it sticks.

FINAL OUTPUT: a table — for each LIVE post: subreddit, title, the sourced research
insight, and the direct /comments/ permalink. Then list any subs skipped (with the
blocker you saw).

Change Weekly (Tuesday 10:00) to whatever fits — Weekly (Sunday 09:00), or a raw cron like Cron (0 10 * * 2). Weekly or slower is strongly recommended for public posting.

Expected Outcome

When the run finishes, you get a summary table you can click through and verify — every link is a real /comments/ permalink the agent confirmed live:

#	Subreddit	Post Title	Research Insight Used	Live Link
1	r/ollama	”Ollama hit 52M monthly downloads by doing ONE thing well — why can’t agent frameworks?”	Ollama’s download growth (100K → 52M in 3 years) and GitHub-star count, with source	`https://old.reddit.com/r/ollama/comments/...`
2	r/opencode	”Your agent doesn’t need 47 tools. It needs 5 and a text editor.”	Tool-count vs. accuracy datapoint + “raw API calls are simpler and cheaper” for single-agent setups	`https://old.reddit.com/r/opencode/comments/...`
3	r/LocalLLM	”Every time I simplify my local AI setup, it gets more reliable. Anyone else?”	A leading open-weight model crossing a reasoning benchmark locally at a fraction of API cost	`https://old.reddit.com/r/LocalLLM/comments/...`
4	r/LangChain	”Hot take: ‘minimal + local’ beats ‘feature-rich + cloud’ for personal agents”	Inference cost-curve shift ($/token over the last year) with source	`https://old.reddit.com/r/LangChain/comments/...`
5	r/aipromptprogramming	”What if your agent’s memory was just markdown files you could grep?”	Open-model adoption / star-growth stat with source	`https://old.reddit.com/r/aipromptprogramming/comments/...`

The subreddits, titles, and insights above are illustrative — the agent vets fresh lenient targets and current, sourced datapoints on each run, and skips any sub whose submit page demands flair, karma, or membership. Treat the table as the shape of the output, not a script.

​Overview

​Video Walkthrough

​Setup

​Required

​Recommended

​Optional

​Before You Start

​The Prompt

​Understanding the Prompt

​How It Works

​Limits

​Automating with Heartbeat

​Expected Outcome

Overview

Video Walkthrough

Setup

Required

Recommended

Optional

Before You Start

The Prompt

Understanding the Prompt

How It Works

Limits

Automating with Heartbeat

Expected Outcome