AI Newsletter Daily

intent

generate a concise daily ai newsletter from fresh web sources, curating the most relevant ai/ml news, releases, research, funding, product launches, model updates, regulation, and benchmarks published in the last 1-14 days. use this skill when the user asks for a current ai digest, ai news roundup, curated newsletter, or daily ai briefing. do not use for evergreen explainers, non-ai topics, or long-form research not intended as newsletter content.

inputs

external connections:

• web_search: brave search api (requires BRAVE_API_KEY env var)
• web_fetch: firecrawl or equivalent html scraper (requires FIRECRAWL_API_KEY env var)

parameters:

• target_news_count (default: 20, bounds: 1-50): number of final articles to return
• search_query (default: "latest AI news today"): initial search term
• search_time_window_days (default: 2, bounds: 1-14): prefer articles from last N days
• max_search_results (default: 60, bounds: 20-120): max candidates to fetch from search
• min_articles_required (default: 10, bounds: 1-50): minimum acceptable verified items before fallback
• include_domains (default: []): whitelist specific domains; empty means no restriction
• exclude_domains (default: ["youtube.com", "reddit.com", "facebook.com", "x.com", "twitter.com"]): block these domains
• summary_model (default: "host-default"): which ai model to use for summaries
• max_scrape_retries (default: 2, bounds: 0-5): retry failed fetches up to N times

validation rules:

• if min_articles_required > target_news_count, clamp to target_news_count
• all numeric bounds are enforced; out-of-range values are clamped

procedure

1. initialize and validate inputs

• apply defaults to any missing parameters
• clamp numeric values to specified bounds
• if min_articles_required > target_news_count, set min_articles_required = target_news_count
• initialize warnings = [], seen_canonical_urls = set(), processed_urls = set(), newsletter_items = []

2. execute initial web search

• call web_search with search_query
• extract all results with non-empty title and url
• if fewer than 1 usable result, trigger decision point: retry with expanded query

3. retry search if needed

• if initial search yielded no usable results, run web_search with fallback query: "{search_query} generative AI LLM model open source enterprise"
• if fallback also returns no usable results, hard-fail with clear message: "no news sources found after initial and fallback searches"

4. normalize and deduplicate candidate urls

• for each search result, canonicalize the url: lowercase hostname, remove utm/tracking parameters, normalize trailing slashes
• filter out results with empty or malformed urls
• drop duplicate canonical urls, keeping the highest-ranked result per url
• add canonical url to seen_canonical_urls

5. apply domain filters

• if include_domains is non-empty, keep only results matching those domains
• remove all results with domain in exclude_domains
• if both filters eliminate all candidates, warn and trigger fallback search

6. score and rank candidates

• for each candidate, assign a relevance score (0-100 scale):
  • ai topic relevance (0-50 points): keyword matching, ai/ml domain signals in title/snippet
  • freshness (0-30 points): within search_time_window_days receives full 30pts; older dates scored lower; unknown dates receive 10pts
  • title/snippet clarity (0-20 points): readability, specificity, no spam signals
• sort by: relevance_score desc, then published_at desc (unknown dates last), then url asc
• keep top target_news_count * 2 candidates for fetching

7. fetch and verify candidates in ranked order

• iterate through ranked candidates until target_news_count verified items are collected
• skip any url already in processed_urls
• attempt web_fetch on each candidate url, with up to max_scrape_retries + 1 total attempts
• if fetch fails (timeout, 404, 403, network error, etc.), add warning with url and reason, then continue to next candidate
• trigger decision point: cross-check verification

8. cross-check fetched page against search result

• compare fetched page title vs search result title (must have >70% string similarity)
• verify fetched page domain matches search result domain
• confirm fetched page content is topically aligned with search snippet
• verify published date on page (if present) is consistent with search metadata (within 1 day margin)
• if page fails any check, skip it, add warning, continue to next candidate
• if page passes all checks, add url to processed_urls

9. generate summary for verified candidate

• call summary model with instruction: "write one plain-text paragraph (max 80 words) explaining why this ai news item matters to practitioners; be factual and neutral; focus on impact, not hype"
• if summary generation fails (timeout, model error, etc.), add warning with url, skip summarization, mark summary as "[summary unavailable]", continue
• enrich the item with: title, url, domain, published_at (or "unknown"), summary, relevance_score, source_query
• append to newsletter_items

10. check minimum quality gate

• if len(newsletter_items) < min_articles_required, run one fallback search: "AI news today machine learning model release funding research"
• process only candidates with canonical urls not in seen_canonical_urls or processed_urls
• repeat steps 4-9 on fallback results only
• add note to warnings that fallback search was triggered

11. final integrity check

• for each item in newsletter_items, verify: non-empty title, valid url, non-empty domain, non-empty summary, source_query present, relevance_score is numeric
• remove and warn on any invalid item
• ensure no duplicate urls in final set
• if final count is still below min_articles_required, note this in warnings (soft fail, not a hard fail)

12. sort, truncate, and render

• sort newsletter_items by: relevance_score desc, then published_at desc
• truncate to target_news_count
• render markdown newsletter with h1 date header, h2 per article, summary paragraph, source link
• assemble json newsletter object with date, query, count, articles array, warnings array

13. return all outputs

• return newsletter_items (list of objects)
• return markdown_newsletter (string)
• return json_newsletter (object)

decision points

if initial search returns no usable results:

• execute fallback search with expanded ai-focused keywords
• if fallback also fails, hard-fail immediately with reason "no news sources found"

if domain filters eliminate all candidates:

• warn user that filters were too restrictive
• trigger fallback search without domain restrictions to meet min_articles_required

if web_fetch fails on a candidate:

• record url and failure reason in warnings
• do not retry the same url within the same skill run
• continue to next candidate in ranked order
• soft-fail (do not stop execution)

if cross-check verification fails:

• skip the candidate entirely
• add warning with url and specific reason (e.g., "title mismatch", "domain inconsistency", "off-topic content")
• continue to next candidate

if summary generation fails:

• mark summary as "[summary unavailable]"
• warn with url and reason
• include the item anyway if all other fields are valid
• continue to next candidate

if final verified count falls below min_articles_required:

• attempt one fallback search (step 10)
• if still below threshold after fallback, soft-fail and return partial result with clear warning
• do not hard-fail unless both initial and fallback searches return zero usable urls

if published_at is missing or malformed:

• use "unknown" as published_at value
• allow the item to pass (unknown dates are not a rejection criterion)
• score freshness lower for unknown-date items (10pts instead of 30pts)

output contract

newsletter_items (list of objects): each item must contain:

• title (string, non-empty)
• url (string, valid url, non-empty)
• domain (string, extracted from url, non-empty)
• published_at (string, iso8601 date or "unknown")
• summary (string, 1-80 words, or "[summary unavailable]")
• relevance_score (number, 0-100)
• source_query (string, the search query that surfaced this result)

markdown_newsletter (string):

• h1 title: "# AI Newsletter Daily , YYYY-MM-DD"
• one h2 per article: "## N. Article Title"
• one paragraph summary under each h2
• one source link per article: "Source: link"
• optional h2 section "## Warnings" with one bullet per warning (only if warnings exist)
• plain-text, no html, no markdown tables

json_newsletter (object):

{
  "date": "YYYY-MM-DD",
  "query": "<search_query_used>",
  "count": <number of articles>,
  "articles": [
    {
      "title": "...",
      "url": "...",
      "domain": "...",
      "published_at": "...",
      "summary": "...",
      "relevance_score": <0-100>,
      "source_query": "..."
    }
  ],
  "warnings": [
    {
      "url": "...",
      "reason": "...",
      "fallback_triggered": <boolean>
    }
  ]
}

outcome signal

the user knows the skill worked when:

• markdown newsletter appears with a date header, at least min_articles_required articles, each with title, summary, and source link
• each article summary is concise (1 short paragraph) and explains why it matters to ai practitioners
• all urls are clickable and correspond to real news articles
• json_newsletter matches markdown_newsletter in article count and content
• if any fetch or summary failed, warnings section lists the failed urls with reasons
• newsletter is sorted by relevance and recency (most important stories first)
• no duplicate urls appear across articles
• skill completes in <30 seconds for typical requests (may be longer if network timeouts occur)