26 production-ready recipes

AI Workflow Recipe Library.

Real, agentic AI workflows you can ship: not toy demos. Each recipe is the architecture, the exact stack, and the guardrails that keep it alive in production. Browse the build, then take it to your own use case.

Recipes
26
Categories
8
Skill range
Beginner → Advanced

Every recipe is the same five-stage pipeline.

Different sources, different models, different destinations. The shape underneath is always this: ingest the world, reason over it cheaply, validate hard, and deliver where work happens. Two rails run the length of it.

Category
Difficulty

26 recipes shown

SEO Automation Intermediate

Crawls a site and scores how citable it is to AI engines, then returns a prioritized fix list.

Why it matters

Know exactly why ChatGPT, Perplexity, and Google AI Overviews skip your pages, and what to fix first to start earning citations.

SEO Automation Intermediate

Compares your coverage to the entities and questions competitors rank for, then outputs prioritized briefs.

Why it matters

Stop guessing what to write. Get a ranked, evidence-backed list of the gaps worth closing, grounded in what is actually on the SERP.

SEO Automation Intermediate

Finds the published pages aging out of AI Overviews, ranks them by decay, and queues a grounded refresh for each before the citations slip.

Why it matters

Freshness is a top citation signal, so pages quietly fall out of AI answers as they age. This keeps a steady queue of the highest-impact updates instead of a once-a-year content audit.

SEO Automation Advanced

Builds a resolved entity knowledge base for your brand, links it to public knowledge graphs, and emits the schema that makes AI engines understand who you are.

Why it matters

AI engines cite sources they can model as entities. A clean, linked entity base makes your people, products, and concepts legible to them, which is the groundwork for being cited at all.

Ecommerce Beginner

Runs every draft Etsy listing through a QA pass, title, tags, images, SEO, and policy, and returns a pass or fix-it checklist before you hit publish.

Why it matters

A listing published with weak tags or a thin description leaks sales quietly for months. This catches the fixable problems in seconds, so every launch goes out at full strength.

Ecommerce Intermediate

Watches a list of ASINs and alerts you the moment a real price drop clears your buy threshold.

Why it matters

Stop refreshing product pages. Buy at the genuine low with full context, current price versus thirty-day floor, the instant it happens.

Ecommerce Intermediate

Researches an Etsy niche end to end and returns a ranked shortlist of product opportunities with rationale.

Why it matters

Replace a week of manual market research with a grounded shortlist that scores demand against competition, so you build what is actually underserved.

Ecommerce Intermediate

A resilient, LLM-assisted pipeline that turns messy retail catalog pages into clean structured product data at scale.

Why it matters

Get a dependable product dataset that survives site redesigns, the failure point that breaks most home-grown scrapers within a month.

Agent Infrastructure Advanced

Routes each request to the cheapest model that can actually handle it, with automatic fallback and budget caps.

Why it matters

Cut LLM spend by a large margin without losing quality. Stop paying frontier prices for trivial extract-and-classify calls.

Agent Infrastructure Advanced

A reference pattern for an assistant that remembers across sessions while keeping the context window small and on-topic.

Why it matters

Ship an assistant that feels like it knows the user without ballooning prompt cost. Separating working from long-term memory is the difference between a demo and a product.

Agent Infrastructure Advanced

Gives every agent its own Durable Object as a strongly consistent memory store at the edge, with SQLite state, alarm-driven decay, and hibernating WebSockets.

Why it matters

Per-user agent memory usually means a database round trip and a consistency headache. A Durable Object collapses state, compute, and locality into one addressable object, so each agent's memory is fast, consistent, and isolated by construction.

Dev Automation Intermediate

Wires a coding agent to pull current, version-pinned library docs through Context7 before it writes a line against an SDK.

Why it matters

Kill the most common failure of coding agents: confidently calling APIs that changed or never existed. Ground generation in real docs and the diff actually compiles.

Dev Automation Advanced

Spins up a per-branch preview deploy, smoke-tests it on the live URL, and posts a pass or fail verdict back to the pull request.

Why it matters

Catch broken builds and regressions before they reach main. Every branch gets a live URL and an automated verdict instead of waiting on someone to click around.

Dev Automation Advanced

Reviews each pull request, pushes low-risk fixes as commits, and loops until the checks pass or it hands back to a human.

Why it matters

Cut review latency from days to minutes on routine PRs. Reviewers spend their attention on design, not on lint, missing tests, and obvious bugs.

Dev Automation Advanced

Fans out a fleet of agents across a codebase to find dead code, duplication, and needless complexity, then verifies each fix in isolation before it ships.

Why it matters

Pay down tech debt at a pace one engineer cannot match. Smaller, simpler code is cheaper to run, faster to change, and easier for the next agent to reason about.

Voice Intermediate

Turns the raw transcripts from an Omi wearable into structured action items, decisions, and follow-ups routed to where you actually work.

Why it matters

Stop losing the good idea you had on a walk. Every captured conversation becomes searchable notes and tracked tasks, with zero manual journaling.

Voice Intermediate

Turns a recorded meeting into attributed decisions and assigned action items, syncs them to your tracker, and chases the ones that go unfinished.

Why it matters

Most meeting notes die in a doc nobody reopens. This assigns every action to a real owner, files it where work actually happens, and follows up so commitments close instead of evaporating.

Voice Advanced

A self-hosted voice front end to a Hermes agent with streaming speech, barge-in, and the full tool and memory stack behind it.

Why it matters

Give customers or staff a natural voice line into your agent, on the web or over the phone, without renting a black-box platform.

Monitoring Beginner

Collapses a wall of industry RSS feeds into one ranked, summarized Telegram digest each morning.

Why it matters

Read five items that matter instead of scanning two hundred. Stay ahead of your space in five minutes a day, fully hands-off.

Monitoring Intermediate

Asks the answer engines your money questions on a schedule and alerts you when your citations appear, vanish, or get replaced by a competitor.

Why it matters

GEO has no rank tracker yet, so build your own. See exactly when ChatGPT, Perplexity, or Google AI Overviews start or stop citing you, before the traffic moves.

Monitoring Intermediate

Watches competitor pages for meaningful change, pricing, positioning, launches, hiring, and tells you what moved and why it matters, filtering out the noise.

Why it matters

Know your competitor moved before your prospect does. Turn scattered page-watching into one signal feed of real strategic changes, without a person diffing screenshots.

Monitoring Intermediate

Builds a baseline of your LLM spend and pages you the moment a key, app, or route burns money abnormally, a runaway loop, a leaked key, a model price jump.

Why it matters

LLM bills do not spike politely; one looping agent or a leaked key can run thousands overnight. This catches the anomaly in minutes, attributes it, and can throttle before the invoice does the talking.

Outreach Intermediate

Researches a shortlist, drafts genuinely personalized first-touch messages grounded in real profile facts, and queues them for human review.

Why it matters

Scale outreach without sounding like a mail merge. Personalization that is actually true lifts reply rates and protects the brand.

Outreach Intermediate

Captures every inbound recruiter message and job lead, scores it against your criteria, tracks it through a pipeline, and drafts the follow-up before it goes cold.

Why it matters

Good opportunities die from slow or forgotten replies, not from lack of interest. This keeps a scored pipeline of every inbound role and nudges you to respond while the conversation is still warm.

Productivity Intermediate

Triages your inbox and calendar each morning into one brief: what needs a reply, what to decline, and what to prep for.

Why it matters

Reclaim the first hour of the day. Instead of a sixty-message inbox and a wall of invites, you get a ranked brief with drafts ready for one click.

Productivity Advanced

Continuously syncs your notes, highlights, and saved links into one entity-resolved knowledge graph your agents can actually query.

Why it matters

Your knowledge is scattered across ten apps. Unify it into a single graph every agent shares, so your assistant answers from what you already know, not the open web.

Monitoring Beginner 2 to 3 hours

Blogwatcher RSS-to-Telegram Digest

Collapses a wall of industry RSS feeds into one ranked, summarized Telegram digest each morning.

StackPython + feedparser, OpenRouter (Haiku-class model), Telegram Bot API, KV seen-store, scheduled trigger.

Why it matters

Read five items that matter instead of scanning two hundred. Stay ahead of your space in five minutes a day, fully hands-off.

How it works

  1. Poll feeds A scheduled job pulls every tracked RSS or Atom feed and de-dupes against a seen-GUID store so each item is processed exactly once.
  2. Score relevance A cheap model routed through OpenRouter rates each new item against your tracked topics and drops anything below threshold.
  3. Summarize survivors Items that clear the bar get a two-sentence summary plus a why-it-matters line, batched to keep token cost near zero.
  4. Compose the digest Results are grouped by topic, sorted by score, and rendered as a clean Telegram MarkdownV2 message with source links.
  5. Deliver and checkpoint Hermes sends the message via the Bot API, then writes a checkpoint so the next run knows exactly where it left off.

Guardrails

  • De-dupe on GUID and normalized URL, never title: syndicated posts repeat across feeds with different headlines.
  • Escape MarkdownV2 reserved characters or Telegram rejects the message. Keep a plain-text fallback.
  • Cap items per feed and per run so a feed that dumps its archive cannot blow your token budget.
  • Wrap every fetch in a timeout and try/except. One dead feed must not kill the whole digest.
  • Log relevance scores and review the scoring rubric weekly. Drift is invisible until you measure it.
Full stack
  • RSS
  • OpenRouter
  • Hermes
  • Telegram
  • Cron
Book a build session
Ecommerce Intermediate 1 day

Amazon Listing Price Drop Watcher

Watches a list of ASINs and alerts you the moment a real price drop clears your buy threshold.

StackCrawl4AI with a Playwright backend, CSS extraction plus LLM fallback via OpenRouter, SQLite price history, Telegram or email alerts.

Why it matters

Stop refreshing product pages. Buy at the genuine low with full context, current price versus thirty-day floor, the instant it happens.

How it works

  1. Define the watchlist Store each ASIN with a target price and cadence. Rotate user agents and hold a polite crawl interval per domain.
  2. Render and extract Crawl4AI loads the JS-rendered product page and pulls price, availability, coupon, and seller, with LLM extraction as a fallback when the DOM shifts.
  3. Normalize and sanity-check Convert to a canonical price record and reject obviously bad parses such as a zero price or one a hundred times the median.
  4. Detect a real drop Compare against rolling history and flag only when the drop clears a percentage threshold and holds across two consecutive checks.
  5. Alert with context Send a card showing current price versus thirty-day low and percent off, then snooze repeat alerts per ASIN for a set window.

Guardrails

  • Expect anti-bot interstitials and CAPTCHAs. Detect them and back off with jitter rather than hammering the host.
  • Layout drift silently breaks CSS selectors. Keep the LLM fallback and alert yourself when parser confidence drops.
  • Filter flicker: a price wobbling around the threshold should not page you every fifteen minutes.
  • Lock the marketplace domain so you never compare prices across currencies or locales.
  • This is for personal or authorized monitoring within rate limits and terms of service, not scraping at scale.
Full stack
  • Crawl4AI
  • OpenRouter
  • Hermes
  • SQLite
  • Telegram
Book a build session
Ecommerce Intermediate 1 to 2 days

Etsy Product Opportunity Research Agent

Researches an Etsy niche end to end and returns a ranked shortlist of product opportunities with rationale.

StackCrawl4AI for search and listing pages, OpenRouter for reasoning and structured extraction, Hermes for persistent niche memory, Sheets or CSV export.

Why it matters

Replace a week of manual market research with a grounded shortlist that scores demand against competition, so you build what is actually underserved.

How it works

  1. Seed and expand Start from one niche keyword. The agent generates adjacent queries and crawls Etsy search and top listings for title, price, reviews, tags, and age.
  2. Structure the data An LLM extracts every listing into a typed row and computes demand proxies such as reviews per month, recency, and price bands.
  3. Cluster into sub-niches Listings are grouped into sub-niches, then summarized as saturated or underserved using the review-to-listing ratio.
  4. Score opportunities Each opportunity is ranked on a demand times margin over competition rubric, and the model must cite the listings behind every score.
  5. Persist and report Findings are written to Hermes memory so later runs build on prior research, then exported as a ranked sheet with rationale and examples.

Guardrails

  • Reviews are a lagging, imperfect demand proxy. Label every score as an estimate, never a guarantee.
  • Force grounded output: an opportunity with no real listing URL behind it is rejected, which kills hallucination.
  • Crawl politely and cache pages so re-runs do not re-fetch and you stay within rate limits.
  • Seasonality skews any snapshot. Stamp the crawl date and re-run before committing inventory.
  • Namespace memory by niche so one project's notes never bleed into another.
Full stack
  • Crawl4AI
  • OpenRouter
  • Hermes memory
  • Google Sheets
Book a build session
Agent Infrastructure Advanced 2 to 3 days

OpenRouter Cost-Aware Model Router

Routes each request to the cheapest model that can actually handle it, with automatic fallback and budget caps.

StackOpenRouter unified API, a classifier plus policy table, Redis for budgets and caching, structured cost and quality logs.

Why it matters

Cut LLM spend by a large margin without losing quality. Stop paying frontier prices for trivial extract-and-classify calls.

How it works

  1. Classify the request A tiny model or a set of heuristics tags every request by task type and difficulty: extract, summarize, reason, or code.
  2. Look up the policy Map each task and difficulty to an ordered model list with price and latency ceilings, gating expensive tiers behind real difficulty.
  3. Route through OpenRouter Call with a models fallback array and provider preferences so cross-provider failover is handled for you on an outage.
  4. Guard the budget Check a rolling spend counter in Redis before each call and downgrade the tier or queue when the daily cap is near.
  5. Observe and retune Log model, tokens, cost, latency, and a quality signal per call, then feed a weekly review back into the policy table.

Guardrails

  • Always set a fallback model list. Single-model routing fails the moment one provider has an outage.
  • Cache idempotent calls on a hash of prompt and parameters to kill duplicate spend.
  • Cap output tokens per tier. Runaway generations are the number one surprise on the invoice.
  • Validate structured output against a schema and retry on the next model up, not the same one.
  • Track quality, not just cost. The cheapest model that fails twice is more expensive than the right one.
Full stack
  • OpenRouter
  • Hermes
  • Redis
  • Observability
Book a build session
Agent Infrastructure Advanced 3 to 4 days

Hermes Memory-Aware Assistant Pattern

A reference pattern for an assistant that remembers across sessions while keeping the context window small and on-topic.

StackHermes agent runtime, embeddings plus a vector store for recall, Postgres for structured facts, OpenRouter with prompt caching.

Why it matters

Ship an assistant that feels like it knows the user without ballooning prompt cost. Separating working from long-term memory is the difference between a demo and a product.

How it works

  1. Tier the memory Split working memory for the current thread from long-term memory for durable facts and preferences. Never dump everything into the prompt.
  2. Write durable facts After each turn, extract lasting facts with metadata and roll up older turns into compact summaries.
  3. Retrieve only what is relevant Embed the query, pull the top relevant memories plus the recent summary, and assemble a tight context window.
  4. Reason with caching Generate with the retrieved context and use prompt caching on the stable system and memory prefix to cut cost and latency.
  5. Reconcile and decay Detect contradictions so new information supersedes old, and archive or decay stale memories on a schedule.

Guardrails

  • Memory poisoning is real. Validate what gets written so hallucinated or adversarial facts never persist verbatim.
  • Precision beats recall. Too many loosely related memories degrade answers and inflate cost.
  • Always namespace by user or tenant. Cross-user memory leakage is a security incident, not a bug.
  • Store provenance and timestamps so the agent can prefer recent, sourced facts when memories conflict.
  • Treat remembered data as PII: encrypt at rest, support deletion, and keep an audit trail.
Full stack
  • Hermes
  • Vector DB
  • OpenRouter
  • Postgres
Book a build session
Ecommerce Intermediate 1 day

Crawl4AI Retail Scraping Workflow

A resilient, LLM-assisted pipeline that turns messy retail catalog pages into clean structured product data at scale.

StackCrawl4AI async crawler on Playwright, a work queue, schema-guided OpenRouter extraction, a Parquet or CSV sink.

Why it matters

Get a dependable product dataset that survives site redesigns, the failure point that breaks most home-grown scrapers within a month.

How it works

  1. Build the frontier Seed category and sitemap URLs into a queue, de-dupe them, and respect robots plus per-host concurrency limits.
  2. Fetch and render Crawl4AI renders JS pages into clean Markdown or HTML and handles pagination and infinite scroll.
  3. Extract with a fallback Try fast CSS or XPath rules first, then fall back to LLM extraction against a strict JSON schema for name, price, SKU, and specs.
  4. Validate every field Type-check and range-check each value and route low-confidence rows to a review bucket instead of the clean set.
  5. Sink and refresh Write to Parquet partitioned by crawl date, then schedule incremental re-crawls and diff against the last snapshot.

Guardrails

  • CSS-only extraction is brittle. The LLM fallback is what keeps the pipeline alive through a redesign.
  • Bound LLM extraction to a schema and a token cap. Free-form extraction is slow and expensive at scale.
  • Detect soft-blocks: a 200 OK with empty or altered HTML, not just HTTP error codes.
  • Politeness through concurrency limits, backoff, and caching keeps you off block lists and within terms.
  • Key on a canonical product id so a retried URL never creates duplicate rows.
Full stack
  • Crawl4AI
  • Playwright
  • OpenRouter
  • Queue
  • Parquet
Book a build session
SEO Automation Intermediate 1 day

AI Search Readiness Audit

Crawls a site and scores how citable it is to AI engines, then returns a prioritized fix list.

StackCrawl4AI for rendering and robots, OpenRouter for content scoring, JSON-LD and llms.txt validation, a scored report.

Why it matters

Know exactly why ChatGPT, Perplexity, and Google AI Overviews skip your pages, and what to fix first to start earning citations.

How it works

  1. Crawl the templates Render the key templates such as home, article, and product, capturing HTML, JSON-LD, headings, and meta.
  2. Check the machine layer Verify robots allows AI crawlers like GPTBot, ClaudeBot, and PerplexityBot, and validate llms.txt, sitemap, and canonical tags.
  3. Score the content layer An LLM grades answer-first structure, question-style headings, entity clarity, and citation-readiness per page.
  4. Validate the schema Parse JSON-LD for Person, Organization, Article, and FAQ correctness and flag missing or malformed types.
  5. Prioritize the fixes Rank findings by impact over effort, emit a fix list with examples, and re-run to track the score over time.

Guardrails

  • Citability is directional, not a ranking promise. Frame the output as readiness, not guaranteed citations.
  • Render JS before judging. Content injected client-side can be invisible to some crawlers.
  • Crawler-allowed and content-good are two different tests. Both layers have to pass.
  • Version the rubric. AI-search best practice moves, so last quarter's score is not comparable otherwise.
  • Sample by template, not every URL. Auditing fifty thousand pages individually just burns tokens.
Full stack
  • Crawl4AI
  • OpenRouter
  • llms.txt
  • Schema.org
Book a build session
SEO Automation Intermediate 1 to 2 days

SEO Content Gap Agent

Compares your coverage to the entities and questions competitors rank for, then outputs prioritized briefs.

StackA SERP or keyword source, Crawl4AI for competitor pages, OpenRouter for entity and question extraction, Hermes to track coverage.

Why it matters

Stop guessing what to write. Get a ranked, evidence-backed list of the gaps worth closing, grounded in what is actually on the SERP.

How it works

  1. Map your coverage Crawl your own site and extract topics, entities, and the questions each page answers into a coverage index in Hermes.
  2. Pull the field For each target query, gather the top-ranking competitor URLs and crawl them.
  3. Extract demand An LLM pulls the entities, subtopics, and people-also-ask style questions that competitors cover.
  4. Diff the sets Compute what the field covers that you do not, weighted by frequency across competitors and by search demand.
  5. Write the briefs Emit prioritized briefs with the target query, missing subtopics, suggested H2s, and internal links, ready for a writer.

Guardrails

  • A gap is not always worth closing. Filter by relevance to your offer, not by volume alone.
  • Ground every recommendation in crawled evidence and reject best-practice filler with no SERP basis.
  • The goal is genuinely better coverage, not keyword stuffing that the model invented.
  • Re-crawl on a cadence. SERPs shift and a closed gap can reopen.
  • De-dupe against existing pages so you improve what ranks instead of cannibalizing it.
Full stack
  • SERP API
  • Crawl4AI
  • OpenRouter
  • Hermes
Book a build session
Voice Advanced 3 to 5 days

Standalone Hermes Voice Portal

A self-hosted voice front end to a Hermes agent with streaming speech, barge-in, and the full tool and memory stack behind it.

StackWebRTC or WebSocket audio, streaming STT via Deepgram, the Hermes agent with tools and memory, streaming TTS via ElevenLabs, OpenRouter for the turn.

Why it matters

Give customers or staff a natural voice line into your agent, on the web or over the phone, without renting a black-box platform.

How it works

  1. Capture audio Stream mic audio over WebRTC, chunk it, and forward it to streaming speech-to-text with partial transcripts.
  2. Detect the endpoint Use voice-activity detection and endpointing to know when the user stopped, and support barge-in so they can interrupt the reply.
  3. Reason with Hermes Send the transcript to the Hermes agent with its tools and memory, and stream the model response token by token.
  4. Speak as it generates Pipe tokens into streaming text-to-speech so audio starts before the full reply exists, keeping perceived round-trip near one second.
  5. Persist the turn Log the transcript and any actions to Hermes memory so the next call remembers the context.

Guardrails

  • Latency is the product. Stream every stage: a three-second silence feels broken even when the answer is perfect.
  • Handle barge-in by stopping TTS instantly when the user speaks, or the experience feels robotic.
  • STT errors compound. Confirm high-stakes actions before any tool call executes.
  • Plan for silence, noise, and hang-ups. Always keep a timeout and a human or voicemail fallback.
  • Voice cost and privacy add up fast. Record consent and redact sensitive audio and transcripts.
Full stack
  • Hermes
  • Deepgram
  • ElevenLabs
  • WebRTC
  • OpenRouter
Book a build session
Outreach Intermediate 1 day

LinkedIn Recruiter Outreach Workflow

Researches a shortlist, drafts genuinely personalized first-touch messages grounded in real profile facts, and queues them for human review.

StackAuthorized profile data, OpenRouter for drafting, Hermes for per-candidate context and status, a CRM or sequencer, human approval in the loop.

Why it matters

Scale outreach without sounding like a mail merge. Personalization that is actually true lifts reply rates and protects the brand.

How it works

  1. Intake the shortlist Load an authorized candidate list and the role brief, and store each profile's salient facts in Hermes.
  2. Research the hook Summarize each background and find the one specific, true detail that makes a message non-generic.
  3. Draft the sequence Generate a short personalized first message plus two follow-ups against a tone and brand guide, never inventing credentials.
  4. Route for review Send drafts to a human approval queue, and feed edits back as examples that improve future drafts.
  5. Send and track Push approved messages to the sequencer or CRM, then log replies and update candidate status in Hermes.

Guardrails

  • Human-in-the-loop is mandatory. Automated send at scale is how you get flagged and damage the brand.
  • Hooks must be true. A wrong 'I loved your work on X' is worse than a generic opener.
  • Respect platform terms, rate limits, and consent rules. This is for authorized recruiting, not spam.
  • Cap volume and add jitter. Bursty outreach patterns get accounts restricted.
  • Track opt-outs centrally and honor them across every sequence.
Full stack
  • OpenRouter
  • Hermes
  • CRM
  • Email
Book a build session
Dev Automation Advanced 2 to 3 days

Cloudflare Pages Preview Deployment Agent

Spins up a per-branch preview deploy, smoke-tests it on the live URL, and posts a pass or fail verdict back to the pull request.

StackGitHub Actions trigger, Wrangler deploy to a Cloudflare Pages preview, Playwright smoke checks, OpenRouter for diff-aware test selection, Hermes for per-branch deploy state.

Why it matters

Catch broken builds and regressions before they reach main. Every branch gets a live URL and an automated verdict instead of waiting on someone to click around.

How it works

  1. Trigger on push On every branch push or pull request, a GitHub Action builds the site and calls Wrangler to publish a Pages preview under a unique per-branch alias.
  2. Map the change The agent reads the diff and routes only the affected routes into a smoke-test plan, so a copy tweak never triggers the full suite.
  3. Smoke-test the preview Playwright hits the live preview URL for status codes, console errors, broken assets, and Core Web Vitals on the changed pages.
  4. Judge and comment A model summarizes any failures in plain language and posts a pass or fail verdict with the preview link and screenshots back to the PR.
  5. Promote or hold A green run unblocks merge; a red run blocks it and records the failure signature in Hermes so flaky checks become visible over time.

Guardrails

  • Preview deploys are ephemeral. Tear them down on branch delete so you do not accumulate hundreds of stale aliases.
  • Never point a preview at production data or secrets. Use a separate environment and scoped tokens.
  • Gate merge on the verdict but keep a manual override. A smoke check is a safety net, not a release authority.
  • Pin the Wrangler version and compatibility date so a preview runs what production will actually run.
  • Treat a flaky check as a bug. Track failure signatures and quarantine noisy tests before people learn to ignore red.
Full stack
  • Cloudflare Pages
  • Wrangler
  • GitHub Actions
  • OpenRouter
  • Hermes
Book a build session
Dev Automation Advanced 2 to 3 days

GitHub PR Review and Fix Loop

Reviews each pull request, pushes low-risk fixes as commits, and loops until the checks pass or it hands back to a human.

StackGitHub webhooks and API, OpenRouter for review and patch generation, a sandboxed runner for tests, Hermes for per-repo conventions, CI as the source of truth.

Why it matters

Cut review latency from days to minutes on routine PRs. Reviewers spend their attention on design, not on lint, missing tests, and obvious bugs.

How it works

  1. Ingest the diff A webhook fires on PR open or update. The agent pulls the diff, the touched files, and the repo's conventions stored in Hermes.
  2. Review against a rubric A model checks correctness, missing tests, security smells, and house style, citing exact lines rather than vague advice.
  3. Propose fixes as commits Low-risk findings such as formatting, simple bugs, and missing null checks become a patch the agent pushes to the branch, not just a comment.
  4. Run the loop CI re-runs on the new commit; the agent reads the results and iterates until the checks pass or it hits a confidence or attempt ceiling.
  5. Hand off cleanly Anything ambiguous or high-risk is summarized for a human with the agent's reasoning attached, never silently merged.

Guardrails

  • Never auto-merge. The loop prepares a PR for a human decision; the merge button stays human.
  • Cap the iteration count. An agent chasing a flaky test with commit after commit burns CI minutes and trust.
  • Scope write access to a bot identity behind branch protection, so the agent can never touch main directly.
  • Ground every comment in the diff. A review that invents problems outside the changed lines erodes confidence fast.
  • Keep humans on security-sensitive paths. Auth, payments, and migrations route to a person regardless of the verdict.
Full stack
  • GitHub API
  • OpenRouter
  • Hermes
  • Playwright
  • CI
Book a build session
Voice Intermediate 1 to 2 days

Omi Conversation Insight Pipeline

Turns the raw transcripts from an Omi wearable into structured action items, decisions, and follow-ups routed to where you actually work.

StackOmi developer webhooks for transcripts, OpenRouter for extraction and classification, Hermes for a personal memory store, Notion or a task app as the sink.

Why it matters

Stop losing the good idea you had on a walk. Every captured conversation becomes searchable notes and tracked tasks, with zero manual journaling.

How it works

  1. Receive the transcript Omi posts each finished conversation to a webhook with the transcript, speaker labels, and timestamps.
  2. Segment and classify A model splits the session into topics and tags each as a decision, task, idea, or small talk to discard.
  3. Extract structured items Action items get an owner and a due date where stated, decisions get their rationale, and ideas get a one-line title, all against a strict schema.
  4. Resolve against memory New items are matched to existing threads in Hermes so a recurring project accretes context instead of spawning duplicates.
  5. Route to the destination Tasks land in your task app, notes in Notion, and a daily digest summarizes what was captured and what still needs a decision.

Guardrails

  • Consent first. Recording conversations has legal and ethical limits; capture and honor consent before anything is stored.
  • Transcripts are noisy. Never auto-send an email or create a calendar invite straight from a raw extraction.
  • Redact sensitive content. Health, financial, and third-party personal details get filtered before they reach any external tool.
  • De-dupe aggressively. The same plan mentioned three times in one walk should produce one task, not three.
  • Keep it personal. Namespace the memory to you and encrypt it; conversation data is among the most sensitive you can hold.
Full stack
  • Omi
  • Webhooks
  • OpenRouter
  • Hermes
  • Notion
Book a build session
Monitoring Intermediate 1 to 2 days

AI Search Citation Drift Monitor

Asks the answer engines your money questions on a schedule and alerts you when your citations appear, vanish, or get replaced by a competitor.

StackA tracked question set, OpenRouter and the Perplexity API for live answers, Crawl4AI for AI Overviews, Hermes for citation history, scheduled runs with diff alerts.

Why it matters

GEO has no rank tracker yet, so build your own. See exactly when ChatGPT, Perplexity, or Google AI Overviews start or stop citing you, before the traffic moves.

How it works

  1. Define the question set Curate the prompts that matter for your business, the ones a real buyer would ask, and tag each with the page you want cited.
  2. Poll the engines On a schedule, run each question through the answer engines and capture both the response text and the cited sources.
  3. Parse the citations A model extracts which domains and URLs were cited, whether yours appears, in what position, and with what framing.
  4. Diff against history Compare to the last run in Hermes to detect a new citation, a lost citation, a competitor takeover, or a shift in sentiment.
  5. Alert and log Send a concise alert on a meaningful change and append every run to a history you can chart over weeks.

Guardrails

  • Answer engines are non-deterministic. Treat one run as noise; confirm a change across two or three runs before alerting.
  • Respect each API's terms and rate limits. This monitors your own visibility, it does not scrape engines at scale.
  • Normalize URLs and domains before diffing, or you will page yourself over a trailing slash.
  • Track framing, not just presence. Being cited as the cautionary example is not the win a raw count implies.
  • Version the question set and stamp every run. A reworded prompt is not comparable to last week's answer.
Full stack
  • OpenRouter
  • Perplexity API
  • Crawl4AI
  • Hermes
  • Cron
Book a build session
Dev Automation Intermediate Half a day

Context7 MCP Documentation Grounding Workflow

Wires a coding agent to pull current, version-pinned library docs through Context7 before it writes a line against an SDK.

StackContext7 MCP server, an MCP-capable agent on OpenRouter, a resolve-then-query step ahead of code generation, Hermes to cache resolved library IDs.

Why it matters

Kill the most common failure of coding agents: confidently calling APIs that changed or never existed. Ground generation in real docs and the diff actually compiles.

How it works

  1. Detect the dependency The agent reads the task and the project manifest to identify which libraries and versions the change will touch.
  2. Resolve the library Through Context7 MCP, resolve each library name to a canonical ID, preferring the version the project actually pins.
  3. Pull focused docs Query Context7 with the specific question, not the whole manual, so the context window holds the relevant API surface and examples.
  4. Generate against the docs The agent writes code with the retrieved documentation in context and cites which API it relied on, so the claim is checkable.
  5. Verify and cache Compile or type-check the result, then cache the resolved library ID in Hermes so repeat tasks skip the lookup.

Guardrails

  • Pin to the project's version. Docs for the latest release will mislead an agent working on a pinned older one.
  • Retrieve narrowly. Dumping a whole library's docs into context is slow, costly, and buries the relevant call.
  • Grounding reduces hallucination; it does not remove the compile step. Always build before trusting the output.
  • Cache with a TTL. A resolved ID is stable, but docs move, so do not serve stale guidance forever.
  • Fall back gracefully. If Context7 has no entry for a niche library, flag the uncertainty instead of guessing the API.
Full stack
  • Context7
  • MCP
  • OpenRouter
  • Hermes
Book a build session
Dev Automation Advanced 3 to 5 days

Multi-Agent Codebase Simplification Sprint

Fans out a fleet of agents across a codebase to find dead code, duplication, and needless complexity, then verifies each fix in isolation before it ships.

StackA planner on OpenRouter, parallel worker agents in isolated git worktrees, Playwright and CI as the verification gate, Hermes to dedupe findings across agents.

Why it matters

Pay down tech debt at a pace one engineer cannot match. Smaller, simpler code is cheaper to run, faster to change, and easier for the next agent to reason about.

How it works

  1. Map and chunk A planner agent indexes the repo and splits it into independent units a worker can own without stepping on another.
  2. Fan out the finders Parallel agents scan their chunk for dead code, duplicated logic, over-abstraction, and dependency bloat, each writing findings to a shared store.
  3. Dedupe and rank Findings are merged in Hermes, deduped across overlapping chunks, and ranked by payoff over risk so the safe wins go first.
  4. Fix in isolation Each accepted change runs in its own git worktree so parallel edits never collide, with the full test suite as the gate.
  5. Verify and stage A reviewer agent confirms behavior is unchanged, then opens small, single-purpose PRs a human can actually read.

Guardrails

  • Behavior must not change. A simplification that alters output is a bug, so close test gaps before you start.
  • Isolate parallel work in worktrees or branches, or two agents will silently clobber the same file.
  • Keep PRs small and single-purpose. A thousand-line cleanup is unreviewable and will sit forever.
  • A reviewer agent is not a human reviewer. Keep a person on the merge, especially for public APIs and shared utilities.
  • Measure before and after. If the change does not cut lines, complexity, or cost, it is churn, not simplification.
Full stack
  • OpenRouter
  • Hermes
  • Git worktrees
  • Playwright
  • CI
Book a build session
Productivity Intermediate 1 to 2 days

Calendar and Gmail Triage Agent

Triages your inbox and calendar each morning into one brief: what needs a reply, what to decline, and what to prep for.

StackGmail and Google Calendar APIs, OpenRouter for classification and drafting, Hermes for sender history and your preferences, a scheduled morning run.

Why it matters

Reclaim the first hour of the day. Instead of a sixty-message inbox and a wall of invites, you get a ranked brief with drafts ready for one click.

How it works

  1. Pull the window Each morning, fetch unread mail and the day's events, plus the sender and meeting history from Hermes for context.
  2. Classify and rank A model sorts mail into reply-now, read-later, delegate, and archive, and flags meetings that lack an agenda or conflict.
  3. Draft the responses For reply-now items it generates a short draft in your voice; for low-value invites it drafts a polite decline or a delegate note.
  4. Build the brief It assembles one digest: top actions, suggested declines, prep notes per meeting, and anything still waiting on someone else.
  5. Hold for approval Drafts sit in your drafts folder, never sent automatically, so you approve, edit, or discard each in seconds.

Guardrails

  • Never auto-send. The agent drafts and proposes; the send and the accept stay with you.
  • Read-only by default on the calendar. Proposing a decline is fine; canceling someone's meeting unprompted is not.
  • Learn your voice from edits, not assumptions. Feed approved drafts back so the tone converges on yours.
  • Treat inbox content as sensitive. Keep processing private, scope OAuth to the minimum, and never log message bodies.
  • Keep an escape hatch. A VIP sender or a legal or HR thread surfaces to the top, never gets auto-archived.
Full stack
  • Gmail API
  • Google Calendar
  • OpenRouter
  • Hermes
  • Cron
Book a build session
Productivity Advanced 3 to 4 days

Personal Knowledge Graph Memory Sync

Continuously syncs your notes, highlights, and saved links into one entity-resolved knowledge graph your agents can actually query.

StackConnectors for notes, highlights, and bookmarks, OpenRouter for entity and relation extraction, a graph plus vector store, Hermes as the agent-facing memory, scheduled incremental syncs.

Why it matters

Your knowledge is scattered across ten apps. Unify it into a single graph every agent shares, so your assistant answers from what you already know, not the open web.

How it works

  1. Connect the sources Pull from your notes app, read-later highlights, bookmarks, and meeting transcripts on a schedule, tracking what changed since the last run.
  2. Extract entities and relations A model lifts people, projects, concepts, and the links between them out of each document into a typed graph.
  3. Resolve and merge New entities are matched against existing nodes so one person or project stays a single node, not five near-duplicates.
  4. Index for retrieval Store the graph alongside embeddings so agents can traverse relationships and run semantic search over the same memory.
  5. Expose as a tool Publish the graph to Hermes as a retrieval tool every agent shares, and re-sync incrementally as the sources change.

Guardrails

  • Entity resolution is the hard part. A weak merge step gives you a graph full of duplicate people and useless edges.
  • Keep provenance on every node. An agent should be able to cite which note or highlight a fact came from.
  • Sync incrementally. Re-embedding the whole corpus on every run is slow and expensive at any real size.
  • This is your second brain. Encrypt it, keep it private, and support hard deletion of any source.
  • Decay and review. Stale notes should lose weight over time, or old assumptions outvote what you believe now.
Full stack
  • Hermes
  • Vector DB
  • OpenRouter
  • Obsidian
  • Cron
Book a build session
SEO Automation Intermediate 1 to 2 days

AI Overview Content Refresh Queue

Finds the published pages aging out of AI Overviews, ranks them by decay, and queues a grounded refresh for each before the citations slip.

StackSearch Console and citation history as inputs, Crawl4AI to re-read each page, OpenRouter to draft the refresh against current sources, Hermes for per-URL refresh history, a scheduled queue builder.

Why it matters

Freshness is a top citation signal, so pages quietly fall out of AI answers as they age. This keeps a steady queue of the highest-impact updates instead of a once-a-year content audit.

How it works

  1. Score the decay Pull each page's age, last-updated date, traffic trend, and citation status, then compute a decay score that flags what is aging out of answers.
  2. Diff against the live answer Crawl the pages now winning the answer for each target query and extract the entities, stats, and sections the stale page is missing.
  3. Draft the refresh A model proposes concrete edits: updated figures, new question-style headings, a current-year signal, and a revised summary, each tied to a source.
  4. Queue by impact Rank candidates by traffic at risk over effort and add the top set to a review queue, never rewriting the whole library at once.
  5. Track the outcome After a human ships an edit, bump the updated date, log it in Hermes, and watch whether citations and traffic actually recover.

Guardrails

  • Refresh the facts, do not just churn the date. A timestamp bump with no real change is the kind of signal you get caught faking.
  • Ground every proposed stat in a real, current source. An invented figure in a refresh is worse than the stale one it replaces.
  • Protect the wins. A refresh must not break the headings, anchors, or sections already earning citations.
  • Prioritize by traffic at risk, not age alone. A four-year-old page that still ranks may need nothing at all.
  • Keep a human on the edit. The queue proposes; a person approves before anything republishes.
Full stack
  • Search Console
  • Crawl4AI
  • OpenRouter
  • Hermes
  • Cron
Book a build session
SEO Automation Advanced 2 to 3 days

Entity Knowledge Base Builder

Builds a resolved entity knowledge base for your brand, links it to public knowledge graphs, and emits the schema that makes AI engines understand who you are.

StackCrawl4AI over your own site, OpenRouter for entity and relation extraction, Wikidata and sameAs links for grounding, validated Schema.org JSON-LD output, Hermes as the canonical entity store.

Why it matters

AI engines cite sources they can model as entities. A clean, linked entity base makes your people, products, and concepts legible to them, which is the groundwork for being cited at all.

How it works

  1. Extract your entities Crawl your site and pull the people, products, services, and concepts you cover into typed entity records with the pages that mention each.
  2. Resolve to canonical IDs Match each entity to public identifiers such as Wikidata and official profiles, so an external graph can confirm the thing actually exists.
  3. Map the relations A model infers the relationships, who founded what, which product serves which use case, and assembles them into one coherent internal graph.
  4. Generate the schema Emit Person, Organization, Product, and sameAs JSON-LD per entity, validated against Schema.org, ready to drop into the matching pages.
  5. Publish and maintain Store the base in Hermes, feed an entity section into llms.txt, and re-resolve on a cadence so new pages and renamed entities stay in sync.

Guardrails

  • Resolve before you assert. Linking to the wrong Wikidata entity tells engines you are someone else, which beats no link only in the wrong direction.
  • Claim only what is true. sameAs and authorship markup must point to profiles you actually own and control.
  • Validate every JSON-LD block. Malformed schema is silently ignored, so the work has to pass a real validator, not just look right.
  • Keep entities and content in lockstep. Schema describing a product the page never mentions reads as spam to a parser.
  • Version the base and re-resolve. Public knowledge graphs change, and a stale sameAs is a slow leak of authority.
Full stack
  • Crawl4AI
  • OpenRouter
  • Wikidata
  • Schema.org
  • Hermes
Book a build session
Monitoring Intermediate 1 to 2 days

Competitor Change Detection Agent

Watches competitor pages for meaningful change, pricing, positioning, launches, hiring, and tells you what moved and why it matters, filtering out the noise.

StackCrawl4AI for rendered snapshots, content hashing plus semantic diff, OpenRouter to classify and summarize changes, Hermes for snapshot history, scheduled runs into Slack or email.

Why it matters

Know your competitor moved before your prospect does. Turn scattered page-watching into one signal feed of real strategic changes, without a person diffing screenshots.

How it works

  1. Define the watch list List the competitor URLs that carry signal, pricing, product, homepage, careers, changelog, and set a polling cadence per page.
  2. Snapshot and hash Render each page, store a clean text snapshot, and hash the meaningful content so layout noise and rotating widgets do not register as change.
  3. Diff semantically When the hash moves, compute a semantic diff against the last snapshot so a reworded sentence and a real price change are told apart.
  4. Classify and explain A model labels each change, price up, new feature, repositioning, hiring spree, and writes one line on why it matters to you.
  5. Alert and archive Send only material changes to Slack with a before-and-after, and keep the full history so you can chart a competitor's trajectory.

Guardrails

  • Hash the content, not the markup. Analytics tags, CSRF tokens, and rotating banners will fire false alerts otherwise.
  • Filter for materiality. A competitor fixing a typo is not a notification; tune the threshold or people mute the channel.
  • Snapshot the rendered page. Pricing and copy injected by JavaScript are invisible to a raw HTML fetch.
  • Crawl politely and within terms. This is competitive awareness on public pages, not aggressive scraping.
  • Keep history immutable. The value compounds over months, so append a new snapshot, never overwrite the last one.
Full stack
  • Crawl4AI
  • OpenRouter
  • Hermes
  • Slack
  • Cron
Book a build session
Ecommerce Beginner Half a day to 1 day

Etsy Listing QA and Launch Checklist Agent

Runs every draft Etsy listing through a QA pass, title, tags, images, SEO, and policy, and returns a pass or fix-it checklist before you hit publish.

StackEtsy listing data via the API or paste-in, OpenRouter for copy and SEO scoring, a vision model for image checks, Hermes for shop conventions and past edits, a checklist report.

Why it matters

A listing published with weak tags or a thin description leaks sales quietly for months. This catches the fixable problems in seconds, so every launch goes out at full strength.

How it works

  1. Pull the draft Load the draft listing, title, tags, description, price, images, and category, from the Etsy API or a pasted export.
  2. Score the copy A model grades the title and the thirteen tags for search coverage and overlap, and checks the description for answer-first structure and keyword fit.
  3. Check the images A vision model verifies the photo set: lead-image clarity, count, aspect ratio, and whether the listing shows the product in use, not only on white.
  4. Run the policy pass Flag missing attributes, prohibited claims, broken sizing or processing-time fields, and anything that trips Etsy's own listing rules.
  5. Emit the checklist Return a ranked fix-it list with concrete rewrites, mark blockers versus nice-to-haves, and learn your shop's conventions from past approvals.

Guardrails

  • QA the listing, do not auto-publish it. The agent prepares a launch; the publish stays a human decision.
  • Tag suggestions must fit the product. Stuffing high-volume but irrelevant tags gets a listing buried or flagged, not found.
  • Respect Etsy's policies and API terms. This reviews your own shop's drafts, it does not touch anyone else's listings.
  • Vision checks are advisory. A model can misread a stylistic photo, so frame image notes as suggestions, not hard fails.
  • Keep the rubric current. Etsy changes tag limits and listing rules, so version the checklist and review it each quarter.
Full stack
  • Etsy API
  • OpenRouter
  • Vision
  • Hermes
  • Sheets
Book a build session
Monitoring Intermediate 1 day

OpenRouter Spend Anomaly Watchdog

Builds a baseline of your LLM spend and pages you the moment a key, app, or route burns money abnormally, a runaway loop, a leaked key, a model price jump.

StackOpenRouter usage and generation data, a rolling baseline in Redis, an anomaly check on spend per key and route, alerts to Telegram or PagerDuty, an optional auto-throttle hook.

Why it matters

LLM bills do not spike politely; one looping agent or a leaked key can run thousands overnight. This catches the anomaly in minutes, attributes it, and can throttle before the invoice does the talking.

How it works

  1. Ingest the usage Pull spend and token counts per API key, app, and model from OpenRouter on a tight interval and store them as a time series.
  2. Learn the baseline Compute a rolling normal for each key and route, hourly and daily, so the watchdog knows what ordinary spend looks like before it judges a spike.
  3. Detect the anomaly Flag deviations: a key suddenly ten times its baseline, a route looping the same call, an output-token blowout, or a model whose price just changed.
  4. Attribute the cause Group the offending spend by key, app, and route so the alert names the exact source instead of just saying spend is high.
  5. Alert and optionally throttle Page on a real anomaly with the attribution and projected daily burn, and optionally trip a rate cap or disable the key until a human clears it.

Guardrails

  • Baseline per key and route, not globally. A spike on a batch job is normal; the same spike on an idle key is an incident.
  • Alert on rate of burn, not just total. By the time the daily total looks wrong, the money is already spent.
  • Make throttling reversible and scoped. An auto-kill that takes down production traffic is a worse outage than the overspend.
  • Watch for the leaked-key pattern: spend from a new route, region, or model you never call is the classic tell.
  • Suppress duplicate pages. One runaway loop should be a single incident, not an alert every thirty seconds.
Full stack
  • OpenRouter
  • Redis
  • Observability
  • Telegram
  • Cron
Book a build session
Voice Intermediate 2 to 3 days

Voice Meeting Transcript to Action System

Turns a recorded meeting into attributed decisions and assigned action items, syncs them to your tracker, and chases the ones that go unfinished.

StackDeepgram for diarized transcription, OpenRouter for extraction and attribution, Hermes for cross-meeting project memory, a tracker like Linear or Jira, Slack for owner nudges.

Why it matters

Most meeting notes die in a doc nobody reopens. This assigns every action to a real owner, files it where work actually happens, and follows up so commitments close instead of evaporating.

How it works

  1. Transcribe with speakers Run the recording through diarized speech-to-text so every line carries a speaker label and a timestamp, the basis for real attribution.
  2. Extract decisions and actions A model separates decisions, action items, and discussion, then assigns each action an owner and a due date from what was actually said.
  3. Resolve against the project Match items to the right project and prior commitments in Hermes so a recurring standup accretes context instead of spawning duplicate tasks.
  4. Sync to the tracker Create or update tasks with owner, due date, and a link back to the transcript moment, so every task is traceable to its source.
  5. Close the loop Before the next meeting, check which committed actions are still open and send each owner a private nudge with the original quote.

Guardrails

  • Attribution must come from diarization, not a guess. Assigning a commitment to the wrong person erodes trust in the whole system.
  • Confirm owners and dates before creating tasks. A misheard 'I'll take it' should not silently hand someone a deadline.
  • Consent and notice first. Everyone in the meeting should know it is recorded and processed before anything is stored.
  • Redact the sensitive parts. Comp, legal, and personnel discussion get filtered before any task or transcript leaves the system.
  • De-dupe across meetings. The same action restated next week updates the existing task, it does not create a second one.
Full stack
  • Deepgram
  • OpenRouter
  • Hermes
  • Linear
  • Slack
Book a build session
Agent Infrastructure Advanced 2 to 3 days

Cloudflare Durable Object Agent Memory Store

Gives every agent its own Durable Object as a strongly consistent memory store at the edge, with SQLite state, alarm-driven decay, and hibernating WebSockets.

StackCloudflare Workers routing to one Durable Object per agent or session, embedded SQLite for durable state, alarms for summarization and decay, the Agents SDK for the runtime, Vectorize for semantic recall.

Why it matters

Per-user agent memory usually means a database round trip and a consistency headache. A Durable Object collapses state, compute, and locality into one addressable object, so each agent's memory is fast, consistent, and isolated by construction.

How it works

  1. One object per agent Address a Durable Object by the agent or user ID so all of that agent's memory lives in a single, strongly consistent, single-writer instance.
  2. Store state in embedded SQLite Keep working memory, durable facts, and turn history in the object's built-in SQLite, with no external database round trip on the hot path.
  3. Recall the relevant slice On each turn, query local SQLite for recent turns and pull semantic matches from Vectorize, assembling a tight context window inside the object.
  4. Maintain on an alarm Set a Durable Object alarm to roll up old turns into summaries, decay stale memories, and persist embeddings, all off the request path.
  5. Stream live with hibernation For live agents, hold the client WebSocket with the hibernation API so the object sleeps between messages and bills only when it is working.

Guardrails

  • One object is a single writer. Do not shard an agent's memory across instances, or you reintroduce the consistency problem you came to solve.
  • A Durable Object pins to the region of its first request. Place it near the user, and never assume it will relocate closer later.
  • Keep the hot state small. SQLite in the object is fast, but a multi-megabyte memory blob per turn still costs you latency.
  • Persist before you cache. Write to storage first, then update in-memory state, so an eviction never loses a fact.
  • Namespace and back up. Per-tenant isolation is the win, but you still need export, deletion, and a recovery story per object.
Full stack
  • Durable Objects
  • Workers
  • SQLite
  • Agents SDK
  • Vectorize
Book a build session
Outreach Intermediate 1 to 2 days

Recruiter Opportunity Tracker and Follow-Up Agent

Captures every inbound recruiter message and job lead, scores it against your criteria, tracks it through a pipeline, and drafts the follow-up before it goes cold.

StackGmail intake and a LinkedIn message export, OpenRouter to parse and score each opportunity, Hermes for your criteria and conversation history, Notion or a sheet as the pipeline board, a scheduled follow-up sweep.

Why it matters

Good opportunities die from slow or forgotten replies, not from lack of interest. This keeps a scored pipeline of every inbound role and nudges you to respond while the conversation is still warm.

How it works

  1. Capture the inbound Watch your inbox and messages for recruiter and opportunity threads, and extract the role, company, comp signals, and recruiter into a structured record.
  2. Enrich and score Pull public company and role context, then score fit against your stated criteria: location, level, domain, and compensation floor.
  3. Track the pipeline Place each opportunity on a board with a stage, new, replied, screening, on hold, so nothing sits unattended in an inbox.
  4. Draft the next touch For threads that need a reply, draft a short, accurate response in your voice; for stalled ones, draft a warm check-in grounded in the last exchange.
  5. Sweep for staleness On a schedule, surface opportunities going cold, no reply in a set window, and queue the follow-up draft for your one-click approval.

Guardrails

  • Draft, never auto-send. These are your professional relationships; you approve every message before it goes out.
  • Score against your real criteria, not prestige. A high-status role that fails your location or level filter is still a no.
  • Keep it accurate. A follow-up that misremembers the role or the recruiter's name does more harm than a slow reply.
  • Treat the data as private. Comp figures and job-search activity are sensitive; keep the pipeline encrypted and off shared tools.
  • Honor closed threads. A declined or dead opportunity leaves the follow-up rotation, it does not get nudged forever.
Full stack
  • Gmail API
  • OpenRouter
  • Hermes
  • Notion
  • Cron
Book a build session

A recipe is the map. I build the road.

Every workflow here is one I can stand up on your stack, wired to your tools, with the guardrails that keep it running when you are not watching. Start with a free 30-minute call: bring the problem, and we will scope the build.