Originally published on Towards AI.

I have become less interested in whether a cheap model can “browse the web” and more interested in whether it can run a boring workflow correctly every morning.

That is a different problem.

Most low-cost or free LLMs fail at web automation because the model has to do too much at once. It has to understand the goal, inspect the page, decide where to click, recover from layout changes, parse the result, and then write something useful. One weak link ruins the whole run.

The workaround is simple: do not ask the free model to operate the browser.

Use the free model as the dispatcher. Let MediaUse handle the browser work through site plugins. The model calls semantic commands like “get Hacker News top stories” or “read this Reddit thread.” MediaUse turns those commands into stable browser actions and returns structured JSON.

In this article, I will build a daily pipeline that:

1. Uses OpenClaw with OpenRouter’s free openrouter/owl-alpha model as the orchestrator.
2. Uses MediaUse Hacker News skill to find today’s technical stories.
3. Uses MediaUse Reddit skill to collect user reactions.
4. Uses MediaUse ChatGPT skill to turn the research into a Medium draft.
5. Saves the article draft locally.
6. Runs every day around 10:00 AM.

The result is a low-cost agent that does not depend on a frontier model for every step. The free model plans and routes. MediaUse performs the web operations. ChatGPT is optional and only used at the end because I want the final writing to be good.

If you want the strictest “zero API spend” version, skip the ChatGPT step and ask owl-alpha to write the draft from the collected JSON. If you already have access to ChatGPT through the web UI, the MediaUse ChatGPT skill can use that browser workflow instead of sending paid API calls.

Current caveat: OpenRouter lists openrouter/owl-alpha as free during its current availability window, with tool support and a large context window. Free model availability can change, so check the model page before relying on it in production.

Why this works better than “LLM, please browse the web”

A general browser agent has to reason over pixels and HTML. A site plugin does not.

MediaUse skills package website actions into predictable commands. The Hacker News skill has commands like:

mediause hackernews get top --limit 20 --json
mediause hackernews read item --id <item_id> --depth 2 --replies 20 --max-length 2000 --json

The Reddit skill has commands like:

mediause reddit search posts --query "open source AI agent" --subreddit "LocalLLaMA" --sort relevance --time day --limit 10 --json
mediause reddit read item --post-id <post_id> --sort top --limit 30 --depth 3 --max-length 3000 --json

The LLM does not need to know where the Reddit search box is. It does not need to scroll through nested comments. It just asks for the operation.

That is the whole trick.

Low-quality models often struggle when the task is open-ended. They do much better when the action space is small, named, and structured. MediaUse gives them that smaller action space.

The pipeline

Here is the workflow I use:

10:00 AM
 |
 v
OpenClaw wakes up the workflow
 |
 v
OpenRouter owl-alpha chooses the plan
 |
 v
MediaUse Hacker News skill fetches today's top tech stories
 |
 v
MediaUse Reddit skill searches for matching user reactions
 |
 v
Research JSON is normalized into one brief
 |
 v
MediaUse ChatGPT skill writes a Medium draft
 |
 v
Draft is saved to ./drafts/YYYY-MM-DD-medium-draft.md

Step 1: install and configure MediaUse

On Windows, install or update the MediaUse CLI:

powershell -C "iwr https://release.mediause.dev/install.ps1 -UseBasicParsing | iex"
mediause --version

Configure your MediaUse key:

mediause manage key <your_mediause_key> --json

Install the site plugins:

mediause plugin add hackernews --json
mediause plugin add reddit --json
mediause plugin add chatgpt --json

Bind the accounts:

mediause auth list --json

# Hacker News supports guest read workflows.
mediause use account hackernews:guest --policy balanced --json# Reddit usually works best in visible mode.
mediause use account reddit:<account_id> --policy balanced --show --json# ChatGPT needs your account context if you use it for writing.
mediause use account chatgpt:<account_id> --policy balanced --json
mediause auth health --json

Step 2: configure OpenClaw to use OpenRouter Owl Alpha

Create an OpenRouter API key, then set it in your shell:

$env:OPENROUTER_API_KEY = "<your_openrouter_key>"

Use openrouter/owl-alpha as the model for the orchestration agent. The exact OpenClaw config shape may differ depending on your version, but the important part is the provider, base URL, and model:

provider: openrouter
base_url: https://openrouter.ai/api/v1
model: openrouter/owl-alpha
api_key_env: OPENROUTER_API_KEY
temperature: 0.2

You can sanity-check the model directly with OpenRouter’s OpenAI-compatible API:

$body = @{
 model = "openrouter/owl-alpha"
 messages = @(
 @{
 role = "user"
 content = "Return a JSON plan for collecting today's developer news."
 }
 )
 response_format = @{ type = "json_object" }
} | ConvertTo-Json -Depth 10

Invoke-RestMethod `
 -Uri "https://openrouter.ai/api/v1/chat/completions" `
 -Method Post `
 -Headers @{
 Authorization = "Bearer $env:OPENROUTER_API_KEY"
 "Content-Type" = "application/json"
 } `
 -Body $body

Step 3: give the agent a narrow prompt

The prompt matters. Do not ask the model to be creative with the workflow. Ask it to call a small set of commands and produce a strict output.

Use this as the system prompt for the OpenClaw workflow:

You are a daily technical research dispatcher.

Your job is to collect material for one Medium article draft.Rules:
- Use MediaUse commands only for website data collection.
- Prefer structured JSON outputs.
- Do not browse manually.
- Do not invent article facts.
- Keep the final research bundle under 12,000 words.
- Stop if a site returns a risk prompt, captcha, or account challenge.Workflow:
1. Get today's top Hacker News stories.
2. Select 3 to 5 stories about projects, developer tools, AI infrastructure, open source, or software engineering.
3. Read each selected HN item with comments.
4. For each selected story, search Reddit for matching discussion.
5. Read the most relevant Reddit thread when available.
6. Build a research bundle with:
 - title
 - source URL
 - why it matters
 - HN discussion summary
 - Reddit user feedback summary
 - notable disagreement
 - possible article angle
7. Send the research bundle to ChatGPT through the MediaUse ChatGPT skill to draft a Medium article.
8. Save the draft as Markdown.

This is where a free model becomes useful. It is not being asked to perform delicate web interaction. It is choosing from a menu.

Step 4: collect Hacker News stories

Start with the Hacker News guest context:

mediause use account hackernews:guest --policy balanced --json
mediause hackernews get top --limit 30 --json | Out-File .\run\hn-top.json -Encoding utf8

Then read the selected threads:

mediause hackernews read item --id <item_id> --limit 50 --depth 3 --replies 30 --max-length 4000 --json |
 Out-File .\run\hn-<item_id>.json -Encoding utf8

For example, the agent might decide that a new open source developer tool is worth covering because the HN thread has a lively argument about whether it solves a real problem or just wraps existing tooling.

That disagreement is useful. A good article needs friction.

Step 5: collect Reddit reactions

For each selected story, search Reddit:

mediause use account reddit:<account_id> --policy balanced --show --json
mediause auth health --json

mediause reddit search posts `
 --query "<project name or story title>" `
 --sort relevance `
 --time day `
 --limit 10 `
 --json |
 Out-File .\run\reddit-search-<slug>.json -Encoding utf8

Then read the strongest matching thread:

mediause reddit read item `
 --post-id <post_id> `
 --sort top `
 --limit 50 `
 --depth 3 `
 --replies 30 `
 --max-length 5000 `
 --json |
 Out-File .\run\reddit-<post_id>.json -Encoding utf8

I like Reddit for this step because it gives a different kind of signal than Hacker News. HN is often better for technical critique. Reddit is better for user frustration, adoption stories, jokes, and “I tried this and it broke on my machine” comments.

Step 6: normalize the research bundle

The agent should turn the raw JSON files into a compact research file before asking for a draft.

Here is the shape I use:

{
 "date": "2026-06-08",
 "article_goal": "Explain one practical developer trend from today's discussions.",
 "stories": [
 {
 "title": "Example project title",
 "source": "https://news.ycombinator.com/item?id=00000000",
 "project_url": "https://example.com",
 "why_it_matters": "Short factual reason this story is worth covering.",
 "hn_summary": [
 "What HN users liked.",
 "What HN users questioned.",
 "Any useful technical detail."
 ],
 "reddit_summary": [
 "What Reddit users tried.",
 "Common complaint or praise.",
 "Any adoption signal."
 ],
 "disagreement": "The most interesting tension between the two communities.",
 "article_angle": "A specific angle for a Medium article."
 }
 ]
}

The important part is not the exact schema. The important part is that the drafting model receives organized evidence instead of a pile of comments.

Step 7: ask ChatGPT to write the Medium draft

You can skip this step if you want everything handled by the free OpenRouter model. I keep it because the orchestration model and the writing model do not need to be the same.

The free model is good enough to dispatch commands. For the final article, I want stronger writing.

Use the ChatGPT skill:

mediause use account chatgpt:<account_id> --policy balanced --json
mediause auth health --json

$research = Get-Content .\run\research-bundle.json -Raw
$prompt = @"
Write a Medium article draft from the research bundle below.Style:
- English.
- Technical teaching tone.
- Concrete examples over abstract claims.
- No hype.
- No invented facts.
- Include a clear title.
- Include image placeholders where screenshots or diagrams would help.
- Include code blocks when they explain the workflow better than prose.Research bundle:
$research
"@mediause chatgpt chat ask --prompt $prompt --timeout 120 --new true --json |
 Out-File .\run\chatgpt-draft-response.json -Encoding utf8mediause chatgpt chat read --markdown true --json |
 Out-File .\drafts\$(Get-Date -Format yyyy-MM-dd)-medium-draft.md -Encoding utf8

Step 8: put it together in one script

Here is a simple PowerShell version. Treat it as a starting point, not a perfect production script.

$ErrorActionPreference = "Stop"

$date = Get-Date -Format "yyyy-MM-dd"
$root = "C:\automation\daily-tech-brief"
$runDir = Join-Path $root "run\$date"
$draftDir = Join-Path $root "drafts"New-Item -ItemType Directory -Force -Path $runDir | Out-Null
New-Item -ItemType Directory -Force -Path $draftDir | Out-Null# Keep MediaUse current.
powershell -C "iwr https://release.mediause.dev/install.ps1 -UseBasicParsing | iex"# Hacker News collection.
mediause use account hackernews:guest --policy balanced --json
mediause hackernews get top --limit 30 --json |
 Out-File (Join-Path $runDir "hn-top.json") -Encoding utf8# Ask the orchestrator to select stories and return item IDs.
# This can be an OpenClaw task using openrouter/owl-alpha.
openclaw run .\prompts\select-stories.txt `
 --input (Join-Path $runDir "hn-top.json") `
 --output (Join-Path $runDir "selected-stories.json")$selected = Get-Content (Join-Path $runDir "selected-stories.json") -Raw | ConvertFrom-Jsonforeach ($story in $selected.stories) {
 mediause hackernews read item `
 --id $story.item_id `
 --limit 50 `
 --depth 3 `
 --replies 30 `
 --max-length 4000 `
 --json |
 Out-File (Join-Path $runDir "hn-$($story.item_id).json") -Encoding utf8
}# Reddit collection.
mediause use account reddit:<account_id> --policy balanced --show --json
mediause auth health --jsonforeach ($story in $selected.stories) {
 $slug = ($story.title -replace "[^a-zA-Z0-9]+", "-").Trim("-").ToLower() mediause reddit search posts `
 --query $story.title `
 --sort relevance `
 --time day `
 --limit 10 `
 --json |
 Out-File (Join-Path $runDir "reddit-search-$slug.json") -Encoding utf8
}# Build one research bundle from the collected JSON.
openclaw run .\prompts\build-research-bundle.txt `
 --input $runDir `
 --output (Join-Path $runDir "research-bundle.json")# Draft with ChatGPT through MediaUse.
mediause use account chatgpt:<account_id> --policy balanced --json
mediause auth health --json$research = Get-Content (Join-Path $runDir "research-bundle.json") -Raw
$draftPrompt = @"
Write a Medium article draft from this research bundle.Requirements:
- English
- Practical technical teaching style
- Use code blocks where useful
- Add image placeholders where screenshots should be inserted
- Do not invent facts
- Keep the article publishable after a human edit$research
"@mediause chatgpt chat ask --prompt $draftPrompt --timeout 120 --new true --json |
 Out-File (Join-Path $runDir "chatgpt-draft-response.json") -Encoding utf8mediause chatgpt chat read --markdown true --json |
 Out-File (Join-Path $draftDir "$date-medium-draft.md") -Encoding utf8

The two OpenClaw prompt files can stay short.

select-stories.txt:

Read the Hacker News top stories JSON.

Return JSON only:
{
 "stories": [
 {
 "item_id": "HN item id",
 "title": "story title",
 "reason": "why this is relevant to developers or technology readers"
 }
 ]
}Select 3 to 5 stories about developer tools, AI infrastructure, open source projects, programming, cybersecurity, or startup engineering.
Do not select generic politics, finance, or culture stories unless they directly affect software builders.

build-research-bundle.txt:

Read all JSON files in the run folder.

Create one research bundle for a Medium article.
Return JSON only.For each story, include:
- title
- original URL if available
- HN source URL
- Reddit source URL if available
- factual summary
- HN discussion summary
- Reddit user feedback summary
- strongest disagreement
- suggested article angleDo not invent facts. If Reddit has no matching discussion, set reddit_summary to [] and explain that no strong Reddit signal was found.

Step 9: schedule it for 10:00 AM

Use OpenClaw’s cron scheduler directly. That keeps the whole workflow in the agent layer instead of splitting orchestration between OpenClaw and the operating system.

Create a workflow file such as daily-medium-draft.openclaw.yaml:

name: daily-medium-draft
description: Collect HN and Reddit signals, then create a Medium draft through MediaUse.

schedule:
 cron: "0 10 * * *"
 timezone: "America/Vancouver"model:
 provider: openrouter
 base_url: https://openrouter.ai/api/v1
 model: openrouter/owl-alpha
 api_key_env: OPENROUTER_API_KEYrun:
 command: powershell.exe
 args:
 - "-ExecutionPolicy"
 - "Bypass"
 - "-File"
 - "C:\\automation\\daily-tech-brief\\daily-medium-draft.ps1"

Then register or run the workflow with OpenClaw:

openclaw cron add .\daily-medium-draft.openclaw.yaml
openclaw cron list

If your OpenClaw version uses a different cron command name, keep the same schedule expression and point the job at the same script. The important part is that OpenClaw owns the timing, the model config, and the workflow entry point.

What the daily output looks like

Each morning, you should get a folder like this:

drafts/
 2026-06-08-medium-draft.md

run/
 2026-06-08/
 hn-top.json
 selected-stories.json
 hn-44123456.json
 hn-44123591.json
 reddit-search-example-project.json
 research-bundle.json
 chatgpt-draft-response.json

The draft is not meant to auto-publish. I would not automate that part.

The right workflow is: let the system collect, summarize, and draft while you are doing something else. Then spend 20 minutes editing the piece yourself. Remove weak claims. Add your own opinion. Check links. Replace image placeholders with screenshots.

That still saves most of the work.

Why MediaUse matters here

The interesting part is not that a free model can call an API. That has been possible for a while.

The interesting part is that MediaUse reduces the browser task into a stable site-specific command set.

For a weak model, this is a big deal. It no longer has to solve “how do I use Reddit today?” It only has to decide:

{
 "tool": "mediause reddit search posts",
 "query": "the project name",
 "sort": "relevance",
 "time": "day",
 "limit": 10
}

That is a much easier reasoning problem.

You can think of MediaUse skills as the operational layer between LLM intent and messy websites. The site plugin handles the repeatable workflow. The LLM handles the routing and synthesis.

For automation, that split is usually better than giving one expensive model the whole job.

Cost and quality

This setup keeps the expensive part small.

The free OpenRouter model handles:

• Selecting stories.
• Choosing search terms.
• Building a research bundle.
• Routing the workflow.

MediaUse handles:

• Hacker News retrieval.
• Reddit search and thread reading.
• ChatGPT browser interaction.
• Structured command output.

ChatGPT handles:

• Final article writing.

If you remove the ChatGPT step, the whole workflow can run on free model inference plus MediaUse site operations. If you keep ChatGPT, you are paying only for the part where model quality matters most, or you are using your existing browser account through MediaUse.

That is the practical version of “zero cost”: do not spend premium model tokens on web mechanics.

The part I would not automate

I would not auto-publish the result to Medium.

A daily draft is useful. A daily unattended publication pipeline is how you end up posting a confident summary of something that was wrong, outdated, or based on a joke comment.

Keep a human edit step. It is faster than writing from scratch, and it protects your reputation.

The automation should give you:

• Candidate topics.
• Community reactions.
• A structured research brief.
• A publishable first draft.

You still decide what deserves to be published.

Final thought

The best use of free models is not replacing better models. It is giving them work they can reliably do.

A low-cost model can be a perfectly decent dispatcher when the tools around it are stable. MediaUse makes the web side stable. OpenClaw gives you the scheduler and agent loop. ChatGPT, if you choose to use it, handles the writing pass.

That combination is enough to wake up every morning to a draft that has sources, user feedback, and a real angle.

Not bad for a workflow where the weakest model never has to click a button.

Published via Towards AI

Towards AI Academy

We Build Enterprise-Grade AI. We'll Teach You to Master It Too.

15 engineers. 100,000+ students. Towards AI Academy teaches what actually survives production.

Start free — no commitment:

→ 6-Day Agentic AI Engineering Email Guide — one practical lesson per day

→ Agents Architecture Cheatsheet — 3 years of architecture decisions in 6 pages

Our courses:

→ AI Engineering Certification — 90+ lessons from project selection to deployed product. The most comprehensive practical LLM course out there.

→ Agent Engineering Course — Hands on with production agent architectures, memory, routing, and eval frameworks — built from real enterprise engagements.

→ AI for Work — Understand, evaluate, and apply AI for complex work tasks.

Note: Article content contains the views of the contributing authors and not Towards AI.

---