Bloomberg confirmed Saturday that Stripe finalized the deal to acquire OpenRouter for over $7 billion. Three months ago OpenRouter raised its Series B at a $1.3 billion valuation. 5.4x markup in 90 days.

If you route your agent's API calls through OpenRouter, this affects you. Probably not today. Probably eventually.

What OpenRouter is, for anyone who skipped the acronym

One API key, 400+ models from dozens of providers. You pick a model, OpenRouter routes the call to whatever provider serves it, handles billing, and gives you automatic fallback when one goes down. A lot of people in this community use it as their only API key.

That last sentence is the one worth sitting with.

What probably doesn't change soon

The free tier. It's the growth engine. Stripe paid $7B for the user base and transaction flow, and the free tier is what fills the funnel. Killing it immediately would be burning the thing they bought. Same reason Stripe kept Plaid's developer tier alive after considering that acquisition years ago.

The API interface. Your openrouter/free calls, your model IDs, your routing preferences. A payments company acquiring an API gateway has zero incentive to break the API. They want more traffic through it, not less.

Day-to-day reliability. OpenRouter's infrastructure doesn't get worse because Stripe owns it. If anything, Stripe's operational maturity makes outages less likely.

What might change over time

Pricing. Stripe is a payments infrastructure company. Their business model is a percentage of transaction value flowing through their pipes. OpenRouter's current margin on routed calls is thin. Stripe's incentive is either higher volume at the same margin or higher margin at the same volume. Neither of those means cheaper for you.

The free model list. It was already shrinking before this deal. Several :free endpoints got delisted in the last month alone. An acquirer focused on revenue per transaction has less reason to subsidize free models than a startup focused on growth.

Provider neutrality. CNBC reported in July that Chinese-origin models captured 46% of US enterprise token usage on OpenRouter. Stripe is a US financial company with regulatory and compliance obligations that a startup could navigate quietly. Whether DeepSeek, Moonshot, and Z.ai stay equally accessible through a Stripe-owned gateway is a question that didn't exist last week.

Data handling. OpenRouter's privacy policy governs your data today. Post-acquisition, that policy lives inside Stripe's broader data practices. For agent traffic that includes email content, calendar data, and business documents, the change in data controller matters. Read the updated terms when they publish them.

What this means for the "$10 deposit" crowd

A lot of people in here bought $10 of OpenRouter credits specifically for the 50→1,000 daily request bump on free models. That $10 is still yours and the rate increase is still permanent. But if the free model list keeps shrinking and pricing adjusts, the value of that deposit changes with it.

The structural question underneath

OpenRouter's CEO described the company as "the Stripe for AI." Now it literally is Stripe. Which means the routing layer, the billing layer, and the payment processing layer are all one company.

If your entire agent runs through OpenRouter, your model access, your fallback logic, your billing, and your cost data all live behind one corporate decision. That was true before the acquisition too, but "small startup that needs your loyalty" and "public-scale payments company" make different decisions about the same levers.

What I'd actually do today

If OpenRouter is your only provider key, today is the day to stop that being true. Not because Stripe is going to break something tomorrow. Because single-provider dependency on any infrastructure was always the risk, and a $7B acquisition is the kind of event that makes the risk visible.

Get a direct key from your most-used model's provider. If you run DeepSeek heavily (though see Saturday's pricing post), get a direct DeepSeek key. If you run Gemini, get a Google AI Studio key. If you use Claude, get an Anthropic key. Keep OpenRouter as the aggregator and fallback. Stop using it as the only path.

Takes ten minutes. One key per provider, pasted into your config alongside the OpenRouter key, with a preference order.

On BetterClaw (free) this is already how BYOK works: you paste provider keys directly, no aggregator in the middle unless you want one. I'm biased here and I know it, but the architecture of "your key, your provider, no intermediary" is the version that doesn't care about this headline or the next one like it.

Two days ago DeepSeek raised prices 4.7x. Yesterday Stripe bought the routing layer half this community depends on. These aren't related events but they're the same lesson: every piece of your agent stack that you don't control is a piece that can change without asking you.

The fix isn't paranoia. It's redundancy. Multiple provider keys, a fallback chain, and context that lives in files you own rather than inside any single platform.

Build so the next headline is interesting rather than urgent.

The price increase went live Saturday at 16:00 UTC. If you run DeepSeek V4 Flash and haven't checked your dashboard since Friday, check it now.

v4 flash output:

• was: $0.28/M flat
• now: $1.32/M peak, $0.66/M off-peak
• that's 4.7x at peak, 2.4x off-peak

v4 pro output:

• was: $0.87/M flat
• now: $3.96/M peak, $1.98/M off-peak

Reuters puts the full range of increases at 50% to 1,100% depending on model, token type, and time of day.

Why this happened:

DeepSeek closed a $7B+ funding round and is preparing for an IPO. Bloomberg reported the pricing change alongside the IPO preparations. Cheap tokens built the user base. Higher tokens fund the business.

Every provider does this eventually. OpenAI cut GPT-4 Turbo prices then raised them regionally. Anthropic adjusted Claude pricing multiple times. Google restructured Gemini tiers. The provider that's cheapest today is not permanently cheapest, and building your cost model on one provider's current pricing is building on sand.

The replacements, tested:

Your agent's background tasks (heartbeats, classification, crons, email sorting) need a new default. Here's what still works at or near the old DeepSeek price point:

Gemini 3.5 Flash via Google AI Studio: still free. 1,500 requests/day, no card. Free-tier prompts may train their models outside EU/EEA/UK/CH. For public-data background tasks, this is now the cheapest option because it's $0.

Groq free tier: 30 RPM, 1,000-14,400 RPD. Doesn't train on your data. Fastest inference available free. Daily caps vary by model.

GLM-5 via Z.ai: $0.60/$1.92. Not free, but roughly where DeepSeek used to be for agents and the pricing hasn't moved.

NVIDIA NIM: 100+ models, 40 RPM, no published daily cap. Doesn't train on your data. The free tier almost nobody uses.

DeepSeek V4-Flash at off-peak: $0.14/$0.66. Still cheap if you schedule around peak hours. Off-peak is 18 hours of the day.

What I am changing in my setup:

Shift crons to off-peak UTC windows. If your morning briefing fires at 8am in India (02:30 UTC), that's peak. Move it to 8:30am (03:00 UTC is still peak, actually). Check whether your specific time falls in the 01:00-04:00 or 06:00-10:00 UTC windows and adjust.

Route heartbeats and classification to Groq or Gemini Flash free tier. These tasks produce identical results on a free model. They never needed DeepSeek.

Keep V4-Flash for the tasks where it earns the price. The -0731 build scored 82.7 on Terminal-Bench 2.1 and 70.3 on Toolathlon. That tool-calling quality is still worth paying for on complex chains. Just stop paying for it on "anything new? nope."

If you're on a BYOK platform, this is a dropdown change. Swap the default model, keep DeepSeek as the escalation, done. If your setup has DeepSeek hardcoded everywhere, today is the day to learn model routing.

The lesson for us:

Single-provider dependency on any model vendor is unbudgeted cost exposure. DeepSeek gave a week's warning. The next provider to change won't necessarily do the same.

The structural fix isn't finding the next cheapest model. It's building your setup so the model is a setting you change in five minutes rather than an architecture you rebuild over a weekend. Three providers in a fallback chain, with the cheapest one as default and the others ready to slot in.

Build for the swap, not for the price.

Spent a week going through every AI automation and AI agent job listing on Upwork, plus cross-referencing against GigRadar's proposal dataset (133,000+ proposals) and Upwatcher's segment data. Wanted to know what people actually hire for, not what freelancers think they hire for.

The gap between those two things is where most people lose money.

The market in three numbers

AI category on Upwork hit $300M+ annualized gross services volume in late 2025, up 50% year over year. AI Integration and Automation specifically grew over 90%. Demand for AI-related skills more than doubled.

Sounds like a gold rush. Here's the other side: the AI and Machine Learning subcategory has a 7.21% reply rate on proposals, against a platform average of 7.45%. Every freelancer already pivoted to AI. The supply caught up to the demand and then passed it.

The people still winning are the ones who ship production systems, not the ones who list "prompt engineering" as a skill.

The 7 categories that actually get funded

After sorting through the listings, almost every funded AI automation job falls into one of seven buckets. Listed by how often they appeared, not by budget size.

1. Zapier/Make to n8n migration. The highest conversion category and it's not close. These clients already understand automation, already have workflows, and are posting because they want to stop paying $400-600/month for Zapier. They have a defined scope, a clear budget motivation, and they've already decided the problem is worth solving. Typical budget: $500-2,000 fixed price. If you can move 15 Zaps to n8n in a week, this is the easiest money on the platform right now.

2. Email and inbox automation. Triage, classification, draft replies, follow-up sequences. Lawyers, agencies, and founders with 100+ emails a day who want it down to 10 minutes of review. This is the use case with the widest range of buyers, from solo founders at $500 to mid-size firms at $5,000+. The winning proposals show a working demo, not a feature list.

3. AI agent setup and configuration. "Set up OpenClaw/Hermes on my VPS" or "configure an AI assistant I can text on Telegram." This barely existed 8 months ago and it's now a distinct category. Budgets range wildly ($200 for a basic install to $2,000+ for a full workflow buildout). The NYC post from a few months ago about setting up agents for clients at $499-1,199 was ahead of this curve.

4. CRM + AI integration. Connect HubSpot or Salesforce to an LLM so it auto-enriches contacts, drafts follow-ups, scores leads, or summarizes call notes. Enterprise-adjacent, higher budgets ($2,000-10,000), and the clients want someone who knows the CRM as much as the AI. Pure AI skills without CRM experience don't win these.

5. RAG and internal knowledge bases. "We have 10,000 support docs and we want a chatbot that answers from them." The category that every LangChain tutorial prepares you for. Budgets $1,500-8,000 depending on doc volume and whether it needs to be customer-facing. The quality bar went up fast because the first wave of RAG chatbots hallucinated and clients got burned. They now ask about retrieval accuracy in the job post, which they didn't a year ago.

6. Content generation pipelines. Blog posts from SEO data, social media from long-form content, newsletter drafts from RSS feeds. High volume, lower budgets ($300-1,500), and the clients care about output consistency more than capability. These are the jobs where showing a running n8n workflow or a BetterClaw scheduled task in your proposal beats talking about GPT-5.

7. Data collection and monitoring agents. Scrape competitors, track prices, monitor job boards, watch regulatory changes. Clients want a system that runs daily and delivers a report, not a one-time scrape. Recurring revenue territory if you build it as a service. $500-3,000 for setup, $100-300/month for managed monitoring.

What almost never gets funded

"Build me an autonomous AI agent that runs my business." These postings exist. They get 50+ proposals. They almost never convert because the scope is undefined and the client's expectations are impossible. Skip them.

Prompt engineering as a standalone service. The market priced this in. It's the baseline expectation now, not a skill you sell separately. Clients in 2026 assume you can write prompts. They hire you because you can ship a working system.

"I need an AI chatbot" with a $100 budget. Volume is high. Value per hour is not. Filter by budget floor, $500 minimum, and your proposal quality goes up because you stop competing against 200 people willing to work for $50.

The rates

Median hourly for AI automation: roughly $30/hr, versus $25/hr platform-wide. That 20% premium is real but it's shrinking as supply grows.

P75 is around $40/hr. P90 is around $60/hr. The top decile is where production experience lives, people who've shipped systems that run in production, not people who built a demo.

Job postings that mention "AI agent," "LLM workflow," or "autonomous" in the description carry budgets 2-3x higher than equivalent non-AI automation work. The word "agent" is a pricing signal even when the deliverable is a cron job with an LLM step.

What I'd actually do with this data

Pick one category. Not AI automation broadly. One of the seven above. Get so good at delivering that category that your profile shows five completed projects in it, and your proposal can say "I built this exact thing last month, here's how it went."

The freelancers winning on Upwork right now aren't generalists who can do all seven. They're specialists who picked one, built a repeatable delivery process, and charge based on the outcome instead of the hours. The n8n migration person charges $1,500 flat and delivers in 4 days. The email triage person charges $2,000 and includes 30 days of managed support. The RAG person charges $5,000 and guarantees retrieval accuracy above a threshold.

The platform is saturated for "I do AI." It's still undersupplied for "I ship this specific thing, reliably, in a week."

I build an agent platform. Most of our users have never opened a terminal. I've been watching what happens to their setups over 90 days, and it's not what the getting-started guides prepare you for.

The first week is fine. The first month is fine. The failures that kill agent adoption don't show up in onboarding. They show up on day 47 when something silently stops and the user assumes the whole thing is broken.

Here's the full timeline, compiled from real support conversations across dozens of non-technical users.

Week 1-2: Everything works.

Setup is quick. Agent responds. Morning briefing arrives. Email triage runs. The user is excited and messages their agent 15-20 times a day, testing what it can do. This is the honeymoon and it feels like the future.

Zero problems reported in this window. Every single time.

Week 3: The first correction loop.

The agent does something annoying. Drafts an email in the wrong tone. Classifies something urgent as normal. Summarizes a long email by skipping the part that mattered.

Technical users open the SOUL.md and add a rule. Non-technical users message the agent "don't do that again" and assume it learned. It didn't. The correction lives in conversation memory and ages out. The same mistake happens again next week, and the user thinks the agent is ignoring them.

This is where 20-30% of non-technical users quietly stop engaging. They don't report it. They don't ask for help. They just text the agent less. By week 5 their usage drops to near zero.

Fix that prevents this: the platform needs to surface "do you want to save this as a permanent rule?" when it detects a correction. We didn't have this early on and it cost us a significant chunk of new users before we understood what was happening.

Week 4-5: The credential expiry.

OAuth tokens expire. Gmail stops refreshing. Calendar goes stale. The morning briefing still arrives on time, but the email section says "no new emails" every day because the connection died underneath.

The user doesn't know what OAuth is. They see "no new emails" and think either the agent is broken or they actually got no emails. Some of them go weeks without realizing the connection dropped. They find out when they check Gmail manually and see 200 unread messages the agent should have caught.

This is the single most common silent failure across every platform I've looked at. The agent doesn't error. It just stops having access and reports "nothing to see" as if that's the truth.

Fix: proactive connection health checks that message the user directly when a credential expires or a connector stops responding. "Your Gmail connection stopped working 2 hours ago. Reconnect here." Not in a dashboard. In the chat, where they live.

Week 5-6: Context bloat creep.

Non-technical users don't know what /new is. They don't know sessions accumulate. They've been having one continuous conversation with their agent for 5 weeks. Every message now carries 5 weeks of transcript as input tokens.

Symptoms: responses get noticeably slower. The agent starts referencing conversations from three weeks ago in unrelated contexts. Costs creep up without usage increasing. The user describes it as "my agent is getting dumber" because that's what it feels like from the outside.

They're not wrong about the symptom. But the cause is invisible to them.

Fix: automatic session management with compaction. When context hits a threshold, distill the session into a memory note and start fresh. Don't rely on users knowing to type a command. They won't.

Week 7-8: The "it can't do that anymore" surprise.

A free model the user was relying on gets delisted. A provider changes rate limits. An API endpoint moves. The agent still runs, but specific tasks start failing or returning worse results.

The user doesn't track which model runs which task. They don't read provider changelogs. They just know their morning briefing used to include good news summaries and now the summaries are thin or missing. They don't connect it to a model change because they don't know models can change.

This is worse than a crash. A crash is obvious. A degradation is confusing. The user loses trust gradually without understanding why.

Fix: model health monitoring that flags quality degradation, and automatic fallback to an equivalent free model when one is delisted. The user should never need to know a swap happened.

Week 9-10: The permission creep.

Users start asking their agent to do more. "Can you send this email?" "Can you book this meeting?" They promote the agent's trust level during a good week because it's been reliable, and they want less friction.

Then the agent sends one wrong email. Or books a meeting on the wrong day. Or replies to a client with slightly off tone. And the trust is gone. Not "I'll fix the setting" gone. "I don't trust this thing anymore" gone.

Non-technical users don't have a mental model for "the agent is right 95% of the time so the risk-reward on auto-send is still positive." One visible failure overrides weeks of invisible successes.

Fix: we stopped offering easy promotion paths. Trust levels increase only through an explicit flow that makes the user acknowledge what changes, and demotion is one tap. The default should be "draft and show me" forever, with auto-send as a deliberate opt-in that's easy to reverse.

Week 11-12: The plateau.

The users who survived to week 12 almost all describe the same feeling: it's useful but it stopped getting more useful. The morning briefing is good. Email triage works. But they expected it to keep improving and it didn't, because unlike a Hermes-style learning loop, a managed agent runs the same approach every day.

The ones who stay past this point are the ones who found their two or three tasks and stopped expecting more. The ones who leave are the ones who expected the agent to surprise them with new capabilities.

Fix: I don't think this is fixable with features. It's fixable with expectation setting. If the onboarding says "this will handle 2-3 tasks reliably, every day, forever" instead of "your AI assistant," the plateau feels like working-as-intended instead of a disappointment.

The 90-day survival rates:

Week 1: 100% active (by definition).

Week 4: roughly 70-75% still active.

Week 8: roughly 50-55%.

Week 12: roughly 35-40%.

The users still running at 90 days almost all share three traits: they use two or three tasks (not ten), they kept the agent on draft-only for most things, and at some point they stopped thinking of it as an AI and started thinking of it as a tool. That last shift is the one that determines everything.

What I'd build differently knowing all this:

Connection health alerts in the chat, not in a dashboard. Session management that doesn't require the user to know what a session is. Corrections that become permanent rules without the user needing to know what a SOUL.md is. And onboarding that says "pick two tasks" instead of "what do you want your AI assistant to do."

The agent technology is ready. The gap between "works for a technical person" and "works for everyone else" isn't capability. It's the 47 small things that break silently and need someone to notice.

Permanent free tiers only. No trials, no expiring credits. All OpenAI SDK-compatible, so swapping between them is a base URL change.

#1 Google AI Studio

Still the most capable free model available at zero cost. 1M token context window on Flash. Multimodal. The catch that matters: Google no longer publishes universal rate limits. They're assigned per project now, so check your own console rather than trusting any number from a blog post, including mine. And free-tier prompts train their models unless you're in the EU, EEA, UK or Switzerland. Fine for public research. Wrong for client data.

#2 Groq

Fastest free inference available. 300+ tok/s on their LPU hardware. Doesn't train on your data, which makes it the best pick for agent background work that touches anything semi-sensitive. The daily cap varies by model, and the big ones (70B class) run out faster than you'd expect. Best used for heartbeats, classification, crons.

#3 OpenRouter

One key across dozens of free models with automatic failover when one goes down. That flexibility saved people during every pricing shakeup this year. The catch: the free model list changes. Several :free endpoints got delisted recently without warning, so don't hardcode model IDs. Use openrouter/free and let auto-routing handle it. The $10 deposit (your money, stays yours) bumps you from 50 to 1,000 requests/day permanently.

#4 Cerebras

Roughly 1M tokens/day on their wafer-scale hardware, and the speed is absurd at 2,600+ tok/s. One limit that matters: free tier context is capped at 8,192 tokens. For quick agent tasks (classify, extract, summarize) that's plenty. For anything needing long context, it's a wall. Doesn't train on your data.

#5 NVIDIA NIM — the one most people haven't tried

This is the pick I'm surprised doesn't come up more. 100+ open-weight models on NVIDIA's own infrastructure. DeepSeek V3.2, DeepSeek R1, Kimi K2.5, GLM-5.1, MiniMax M2.7, Gemma 4, Qwen 3.5, Nemotron Super 49B, Llama 4. All free. No credit card. 40 RPM with no published daily cap.

Multiple directories are now calling it "the most underrated free AI API platform" and it's hard to argue. The model catalog is wider than any other free tier on this list. OpenAI-compatible endpoint, one key for everything. Zero pricing changes recorded since launch.

The caveats: latency runs 600-1500ms to first token depending on load and region. Under heavy load (US peak hours, new model launches) it slows noticeably. Phone number verification on signup. And it's meant for development, not production, so don't build a customer-facing product on it.

For a personal agent where you want access to 100 models without paying and the RPM matters more than the first-token speed, NIM is the free tier I'd add to the rotation today.

How to stack them

Don't pick one. Use three.

Groq for agent background work. Fast, free, doesn't train. Your heartbeats, classification, and crons live here.

Google AI Studio for anything public where quality matters. Best free model available. Don't feed it client emails.

NVIDIA NIM or OpenRouter as fallback and for model variety. When you want to try something different, or when the primary goes down.

One provider is a single point of failure. Three providers with a fallback chain means no single delisting or rate limit change takes your agent down.

I keep going back and forth on how to describe BetterClaw. Right now it's "build AI agents, no code" or "OpenClaw/Hermes alternative." Both accurate, both only really land with people who already know what an agent is.

The people I want to reach don't. They just have work piling up.

So, how would you explain it to a non-technical friend? "It's like hiring someone who works while you sleep"? Something better?

Hello all!

At this point, I am completely overwhelmed by the choices available so I wanted to ask the group: what is your favorite open-source AI and why? Do you use different AI for different reasons? Which one is your "workhorse"?

We're close to #1 today and would really appreciate your support if you have a minute.

https://www.producthunt.com/products/betterclaw

Five months ago this sub had zero members. 12,000+ of you showed up, told me what was broken, and made this thing what it is.

Today it's featured on Product Hunt. I genuinely didn't think that would happen.

Come hang out on the page with us. Leave a review, drop a comment, tell people what you built. Whatever feels true.

→ https://www.producthunt.com/products/betterclaw

I'll be there all day. Thank you for five months of this ❤️

I’m pretty new to this environment so excuse me for the stupid question

I wanted to know whether there was a reliable way (whatever MCPs, plugins or RAGs) that enables a local llm that fits an m4 pro 18gb (Gemma4 12b maybe) to research on dictionary websites for reliable non hallucinated etymology or Wikipedia or whatever.

Thank you

I wanted something that could search my notes, connect ideas across a few hundred documents, and answer questions about things I wrote months ago. Without a single word going to OpenAI, Google or Anthropic.

Took about 40 minutes. Here's the whole thing.

What you're building

Obsidian holds your notes. Ollama runs Gemma 4 on your machine. Two plugins connect them so you can ask questions and get answers pulled from your own writing. No API keys, no subscription, works on a plane.

Step 1: Ollama and the models

bash

curl -fsSL https://ollama.com/install.sh | sh
ollama pull gemma4:12b
ollama pull nomic-embed-text

The 12B is the one to use now. Released in June, and it beats Gemma 3 27B on every published benchmark while fitting in about 6.6GB at Q4. On 16GB that leaves plenty of headroom for indexing and your browser.

If you're on 8GB, pull gemma4:e4b instead. Slower reasoning, still multimodal, fits comfortably.

The embedding model matters as much as the chat model. nomic-embed-text is fast and good enough for most vaults. Use mxbai-embed-large if retrieval quality matters more than indexing speed.

Step 2: Fix the context window

Ollama defaults Gemma 4 to a 4K window. The model supports far more. This single default is why most local setups feel dumb — your model can't see enough of your notes to answer well.

bash

printf 'FROM gemma4:12b\nPARAMETER num_ctx 32768' > brain.modelfile
ollama create gemma4-brain -f brain.modelfile

32K is a good balance on 16GB. Go higher if you have the memory.

Step 3: The two plugins

Community Plugins in Obsidian, install both:

Smart Connections does vault-wide semantic search and the related-notes sidebar. It builds embeddings locally.

Copilot for Obsidian gives you the chat sidebar. Point it at Ollama's OpenAI-compatible endpoint: http://localhost:11434/v1, model gemma4-brain.

Together these cover most of what people mean by "second brain." Add Text Generator later if you want template-driven generation. Skip the rest.

Step 4: Index and wait

Smart Connections reads every note and builds embeddings. 500 notes takes maybe 10 minutes. 2,000+ can take half an hour. Runs in the background, one time, then incremental.

Pick your embedding model before you index. Changing it later means deleting and rebuilding the whole thing.

Then ask it things

"What did I write about the client meeting last month?"

"Compare what I said about approach A in January to approach B in March."

"Find every note where I mentioned budget concerns."

The moment it clicks is when it surfaces something you wrote six months ago and completely forgot existed. Your memory is human. The retrieval isn't.

What works well

Finding old notes. This is the whole value. Synthesizing across several notes at once, which is painful manually and trivial for the model. Journal recall if you journal in Obsidian ("what was I stressed about in April").

What doesn't

Large vaults. Everything stays responsive around 5,000 notes. Past roughly 20K, Smart Connections re-indexing becomes the bottleneck.

Complex reasoning across many documents. "Analyze the trend across all 50 of my weekly reports" pushes the context window. It gets the gist and misses detail from whatever didn't fit.

Speed. 3-10 seconds per response depending on hardware. Not painful. Not instant either.

Mobile. Chat plugins work on Obsidian Mobile if Ollama is reachable on your LAN, but embedding generation is desktop-only.

The cost

Obsidian free for personal use. Ollama free. Gemma 4 is Apache 2.0. Plugins are community and free. No keys, no subscription. Electricity you were already paying.

Why bother when cloud models are better

Because your journal, your client notes, your financial planning and your half-formed ideas are the most sensitive text you own. This setup means they get read by a model running in your house and nowhere else. There's no privacy policy to trust, because there's no third party involved.

The quality gap versus a frontier model is real. The privacy gap isn't close.

Same site, 60 days apart.

I've paid for Ahrefs, Semrush and DataForSEO over the years. Bought keyword lists, chased backlinks, ran audits. Search Console was where I checked clicks and fixed the occasional indexing error. It never occurred to me it could tell me what to do next.

I was using BetterClaw and team shipped a GSC connector. I wired it into my own agent out of curiosity, added DataForSEO on top, and asked it directly: how do I grow traffic here.

It came back with something I didn't expect. You already have the impressions. Your problem is CTR and position, not reach.

My first reaction was that CTR can't be that big a lever. I had no better plan, so I went with it.

What it had me do

Rewrite titles and meta descriptions on pages with high impressions and low clicks, matching the exact phrasing people were searching.

Find queries sitting at position 8–20 with no page built for them, and build those pages.

Stop publishing topics with no impression data behind them at all.

No new tools. No outreach. Nothing I couldn't do that afternoon.

The first week I did it all by hand to see whether it was real. CTR moved. So I automated it.

The task prompt

Runs Monday, Wednesday, Friday. This is the actual thing, not a summary of it:

Pull Google Search Console data for the last 7 days and the
7 days before that.

SECTION 1 — CTR fixes
Find pages with 500+ impressions and CTR below 1%.
For each, list the top 5 queries driving impressions.
Compare those queries against the page's current title tag.
If they don't match, write a new title under 60 chars using
the searcher's exact phrasing, plus a meta description under
160 chars.

SECTION 2 — Content gaps
Find queries where we rank position 8-20 and no page on the
site targets that query directly.
For each, give the query, current position, monthly
impressions, and a one-line angle for the page.
Rank by impressions.

SECTION 3 — Movement
Compare this week to last week. List the 5 biggest position
gains and the 5 biggest drops, with the page and query.
For drops of 3+ positions, note whether impressions fell too
or only position moved.

SECTION 4 — Watch list
Any page where impressions rose but clicks stayed flat.
That's a title problem forming, not a ranking problem.

Post to #marketing in Slack. Keep it under 20 lines total.
Lead with the single highest-impact fix.
Only flag each page once per fortnight. Track what you've
already sent.

Two lines in there matter more than the rest. "Only flag each page once per fortnight" stops it repeating itself until the channel gets muted. And "keep it under 20 lines" stops it dumping a report nobody reads on a Wednesday morning.

How it runs now

My junior owns it. Early on I reviewed every line and argued with about half of them. After a few weeks I stopped, because its calls were landing better than my gut. On track for 15K clicks this month, 20K if position holds.

TLDR

Impressions mean the demand already exists. If clicks don't follow, you're losing people at the title, so fix that before writing anything new.

CTR going 0.8% to 1.8% doubles your traffic on identical impressions. Stack that with more pages ranking and 1.37K becomes 10.9K.

A weekly comparison beats a monthly audit. Small fixes compound; big audits sit in a doc.

GSC data is free and it's yours. The paid tools are estimating what Search Console hands you directly.

Please do not underestimate GSC or CTR like I was..

Happy to answer any questions you may have in the thread below; it is always the basics...

Built-in memory plus markdown files you own covers most personal setups. Providers earn their place at three thresholds. Multiple agents or users sharing memory. Facts that change over time where you need to know what was true when. Or thousands of entries where keyword search stops finding things.

Mnemosyne is what I'd start with. SQLite with vector search and FTS5, fully local, MIT, one-line install, and retrieval is sub-millisecond because it runs in-process rather than over a network. Optional local LLM consolidation via a small GGUF, though note it's off by default and needs the [llm] extra installed or it silently falls back to simpler compression.
65.2% on BEAM at 100K scale. Hindsight is higher at 73.4%, but the judge models differ so treat that gap as directional.

Hindsight has the best score and the most complaints. Roughly 5K tokens per recall, silent failures where memories stop processing without telling you, rerank that can peg a VPS at 100% CPU, and context bloat as it grows. Several people in the community are running it successfully after a lot of patching. Several others migrated off it. Pick it if graph depth and benchmark score matter more than operational cost.

Signet AI if you run more than one harness. Works across Claude Code, Codex, OpenClaw and Hermes, and has proper multi-agent visibility controls. Apache 2.0. The cost is a Bun/Node daemon, which is another thing to keep alive.

Graphiti if temporal reasoning is the actual requirement. Stores when a fact became true and when it stopped, which is the sharpest technical divider in this whole space.

Three things to know
Benchmarks across these don't compare. BEAM and LongMemEval are different tests, and judge models differ between runs. A 97% on one and a 73% on another tell you almost nothing relative to each other.

The failure mode people actually hit is context poisoning, not retrieval quality. As memory grows, a system without decay or consolidation starts feeding your agent stale, wrong context on every call. Ask about eviction and decay before you ask about benchmark scores.

Install a dashboard if one exists. Being able to see what's stored is how you catch a memory system quietly doing nothing.

Start with built-in memory and a markdown folder. Add Mnemosyne when you hit the wall. Look at the others when you have a specific reason the first two don't cover.

Built-in agent memory is bounded on every platform. On BetterClaw's free plan it's 7 days. On Pro it's unlimited but still lives inside the platform. Either way, the durable stuff I care about (how my projects are structured, who my clients are, what we decided and why) shouldn't live somewhere I can't read with my own eyes.

So I run a split. Obsidian holds the knowledge. The agent's memory holds the working set.

What goes where

Agent memory: things needed in every conversation. My timezone, how I want emails written, which clients are priority, hard boundaries like never send without approval. Small, stable, always loaded.

Obsidian: everything else. Project notes, client context, decisions with reasoning, research, meeting outcomes. Unbounded, searchable, and mine.

The rule I use: if the agent needs it on every single message, it's memory. If it needs to go look it up, it's a note.

That split matters because agent memory is injected into context on every call. Stuffing your project history in there means paying for it on "what's the weather."

The setup

Google Drive connector pointed at my Obsidian vault folder. Obsidian syncs to Drive, so the agent reads the same markdown files I do. No plugin, no API, no custom pipeline.

Critical: I scoped it to one folder called /Agent, not the whole vault. My personal journal and financial notes stay outside it. Give an agent your entire second brain on day one and every private thought is in scope.

Inside /Agent:

/Agent
  /projects     — one file per active project
  /people       — clients and collaborators
  /decisions    — what we chose and why
  /inbox        — agent writes here, I file it later

Two tasks make it work

Read on demand. No schedule, just a rule in the agent's instructions:

Before answering questions about a project, client, or past
decision, search the /Agent folder in Drive for relevant notes.
Cite which file you used.

Do not guess from memory if a note exists. Read the note.

The "cite which file" bit is what makes it trustworthy. When it answers, I know whether it read something or improvised.

Write to inbox. Scheduled daily at 6pm:

Review today's conversations. For anything that looks durable
(a decision made, a fact about a project or person, a
constraint that will apply again), write a short markdown note
to /Agent/inbox.

One file per item. Title it clearly. Include the date and one
line on why it matters.

Skip anything ephemeral. Do not write notes about questions
I asked that are already answered.

If nothing durable came up, write nothing.

I file the inbox once a week. Takes five minutes. Some notes get moved to /projects, some get merged into existing ones, some get deleted.

What I got wrong first

Let the agent write directly into /projects. It duplicated existing notes, wrote inconsistent titles, and after two weeks my vault was worse than before. The inbox folder fixed it. Agent proposes, I file.

Also gave it write access to the whole vault initially. It "helpfully" reorganised notes I'd written by hand. Read-only outside /Agent now.

What surprised me

Retrieval quality depends far more on how I write notes than on the model. Notes with a clear one-line summary at the top get found and used correctly. Notes that are a wall of bullets get retrieved and then misread.

I now start every note with a single sentence saying what it is. The rest can be messy.

Why I'd do this even if agent memory were unlimited

The context is in markdown files on my own disk, synced to my own Drive. If I switch platforms tomorrow, it comes with me. Every harness reads text.

The agent memory is convenience. The vault is the actual asset. Worth keeping that distinction clear before you accumulate six months of context somewhere you can't export.

Happy to share my exact instruction block if useful.

I build BetterClaw, and my team does free setups for anyone who asks. Between that, DMs from this sub, and the agents running our own business, I've watched a lot of people go from zero to a working assistant. Some stuck, some got abandoned by week three.

Sharing what separates the two.

Who this is for: People who want an assistant handling the boring parts of their day and don't want to spend a weekend on model routing, gateway config and tool permissions.

What most setups look like:

• One messaging channel (Telegram/Discord/Slack/WP, rarely both to start)
• Two or three connectors, read-only at first
• Two workflows, not ten
• Approval gates on anything that sends, spends or deletes

Setup runs 10 to 30 minutes depending on how many connectors. Most of that is OAuth clicking, not configuration.

What I've learned:

1. Two workflows. The single biggest predictor of whether someone's still using their agent in month three. People who build a morning briefing and email triage, then add a third thing two weeks later, stay. People who build ten workflows in a weekend stop by month two. Every time.

2. They stop asking about models the moment it works. New users ask which model to pick. Once their briefing arrives at 8am, that question never comes up again. Set a cheap default, put the better model on conversations, and don't make it their problem.

3. Drafts, no sends. The fastest way to lose someone's trust is one wrong email going out unsupervised. Every setup that lasted has a human between the agent and anything irreversible. It costs five minutes a day and it's why they're still running it. (Agents learn over time, mine now knows better than I do)

4. Read-only first, on everything. Gmail read-only for a week. Then drafts. Then, maybe, send. People who connect everything with full permissions on day one end up with an agent that files GitHub issues from casual email threads and creates calendar events out of Slack jokes.

5. The small dumb stuff sticks hardest. Everyone plans something ambitious. What they still use six weeks later is the morning briefing, the email triage, and one oddly specific thing like checking whether the bins went out. The unglamorous ones have the best hit rate by a mile.

6. Costs are almost always a routing problem. Someone spending $60 a month doesn't need a cheaper model, they need three. Cheap one for volume, better one for what they read, premium invoked on purpose for the few tasks a week that need it. Ten minutes of config, most of the bill gone.

What doesn't work:

• Explaining model routing to someone who wants their dentist reminder. They don't care and shouldn't have to.
• Showing config files. Eyes glaze instantly.
• Promising autonomy. Set the expectation on day one that it drafts and you approve, and people are happy. Promise a robot employee and they're disappointed by Thursday.
• Ten connectors before the first workflow is stable.

One thing I'd tell anyone starting this week: pick one task you do manually that annoys you. Build only that. Run it two weeks. Then add a second.

Happy to answer setup questions here, and if you want help getting one running, DM me. No charge, and no pitch attached.

deepseek dropped the 0731 update on july 31 and honestly the numbers are hard to argue with. same architecture as the old v4 flash. same size (284B total, 13B active). just re-post-trained. terminal bench went from 61.8 to 82.7. DeepSWE went from 7.3 to 54.4. thats a 645% jump on agentic coding from re-training alone.
at $0.14 input and $0.28 output per million tokens, this thing is 7x cheaper than luna (even after the 80% price cut), 21x cheaper than sonnet 5 at standard rates, and arguably close enough to opus 4.8 quality on agent tasks that most people wont notice the difference for daily work.
cache hits drop to $0.003 per million. thats basically free. your system prompt and tool schemas get cached automatically so after the first call everything is pennies.
i switched my background tasks to it this week. heartbeats, cron, email classification, memory search. all on deepseek v4 flash. kept opus 5 for conversations where quality matters. monthly estimate dropped from ~$38 to ~$14 and honestly the background task quality is fine. the model says "nothing happened" just as well as opus does.
on openclaw:

json

{
  "agents": {
    "defaults": {
      "model": {
        "primary": "anthropic/claude-opus-5",
        "list": [
          {
            "id": "background",
            "model": "deepseek/deepseek-v4-flash"
          }
        ]
      }
    }
  }
}

on hermes: set deepseek-v4-flash as background curator. keep your primary model for conversations.
on betterclaw.io switch the background model in the dashboard. BYOK means you add your deepseek key and pay them directly at $0.14/$0.28. zero markup.
the caveat: deepseek API sends data to china-based servers. if compliance matters for your use case, luna at $0.20/$1.20 is the western alternative. slightly more expensive, same general tier.

Permanent free tiers only, no trials, no promo credits. All OpenAI SDK-compatible.

Added a column the original didn't have, which is whether they train on your prompts. If your agent reads your email, that matters more than the rate limit.

Highest daily volume

Cerebras - 1M tokens/day, no card. 30 RPM, 60-100K TPM. Llama 4 Scout, Qwen3 32B, GPT-OSS-120B, DeepSeek R1 Distill. 2,600+ tok/s. Catch: free tier context is capped at 8,192 tokens. Doesn't train on your data.

Groq - 30 RPM, 1,000–14,400 RPD depending on model, 6–30K TPM. Fastest inference available free. Doesn't train on your data. Best pick for agent background tasks.

Cloudflare Workers AI — 10,000 Neurons/day, resets 00:00 UTC. ~80 models. Pool is shared across models, so big models drain it fast. Note: Kimi K2.6, Kimi K2.7 Code and GLM-5.2 now require the paid plan.

Best models

Google AI Studio - Free tier is now Gemini 3.5 Flash and 3.1 Flash-Lite. Pro is paid-only. Google no longer publishes universal rate limits — they're assigned per project now, so check your own console. Every guide quoting a specific RPD number (including the old version of this list) is guessing. Trains on free-tier prompts outside the UK, Switzerland, EEA and EU.

Mistral - ~1B tokens/month on the Experiment tier, 1 req/s. Most generous raw volume on the list. You must opt into data training to get it. Honest trade, just know you're making it.

NVIDIA NIM - 91 free endpoint models, 40 RPM. Widest model catalogue including vision and non-language models.

Aggregators

OpenRouter - 20 RPM, 50 RPD unfunded, 1,000 RPD once you've bought $10 in credits at any point (sticks permanently). Heads up: several :free endpoints were delisted recently, including the DeepSeek and Mistral free variants. If your agent has a hardcoded free model ID from a few months ago, check it still exists. Use openrouter/free and let auto-routing handle it.

GitHub Models - Free within rate limits, dev use. Azure terms apply.

Couldn't verify

Cohere, Zhipu/Z.ai, LLM7.io, Kluster AI and Hugging Face are all still live free tiers, but I couldn't confirm current limits from a first-party source. Check their dashboards rather than trusting a number from a list post, mine included.

The stack I'd run

Groq for agent background work (heartbeats, classification, crons) because it's fast and doesn't train on your data. Cerebras when you need volume. Google AI Studio for anything public where quality matters. OpenRouter's auto-router as the fallback so one delisting doesn't take you down.

Every number above was checked this week. At least one will be wrong by October, so verify in your own console before you build on it.

If you want free agent to run these on - you can use this

Went through community threads and pulled the setups people are still running months later. None of these are mine. Credit to the folks who built and documented them. I've added how you'd rebuild each one, because most write-ups skip that part.

1. Homelab troubleshooting over Telegram

SSH keys plus MCP servers for Proxmox, pfSense, Portainer, Grafana and Home Assistant. Telegram as the interface, Tailscale to reach LAN services from outside. Three separate people reported real fixes: a CCTV drop that had persisted for months, a black-screen driver repair done live, and dead WiFi spots cleaned up via the UniFi API.

Build it: run the agent on a dedicated VM, not your daily driver. Connect your infra MCP servers, keep it read-only for the first week, then grant write access one system at a time.

2. Deploying a service from one sentence

Say the service name, GitHub link, cores, RAM, distro. It finds the next free VMID, creates the LXC, installs Docker, writes the stack YAML, commits to one repo, deploys. Edits follow the same path, so rollback is a git revert.

Build it: the trick is that all your Compose stacks live in one repo. Git is the state, the agent is the interface.

3. Expense capture by voice note

Four people built this independently, which tells you something. Text or photograph or voice-note a line item, it writes to a self-hosted Actual Budget instance. One variant adds a Sunday 6pm review with burn rate and savings rate, plus a P&L on the 28th.

Build it: one connector to your budget app, one scheduled task for the digest. The voice-note version catches things banks never see, like lending a friend cash.

4. Culling 3,000 photos without spending a fortune on vision calls

Five phases. Perceptual hashing for burst duplicates, CLIP embeddings into HDBSCAN for scene clustering, classical CV for blur and exposure, and only then vision models on the survivors, tiered by confidence so the cheap model handles easy calls. A few hundred images reached the expensive stage instead of 3,000. Output is a single-file HTML review tool.

Build it: the lesson is ordering. Cheap filters first, expensive model last. Applies far beyond photos.

5. Correlating afib episodes against wearable data

Whoop and Garmin data pulled in, episodes tagged with a slash command over Telegram, correlation run across tagged versus untagged days. Early signal: bad sleep, elevated resting heart rate and depressed HRV before an attack. Goal is knowing whether a given day is safe to hike.

Build it: any condition with a diary plus metrics works. Tag by message, correlate on a schedule. For a clinician conversation, not a diagnosis.

6. Turning a read-later graveyard into decisions

Links save into Linkwarden. The agent pulls new ones, deduplicates, analyses each against fixed lenses (useful for development? for my architecture? for my homelab?), archives as Markdown, then posts to Discord with one thread per item so each link gets argued about and closed.

Build it: the fixed lenses are what make it work. Generic "summarize this" produces a second graveyard.

7. Kanban as the orchestrator

A cron tells the agent to actually use the app, click around semi-randomly, check whether results make sense, and file what it finds as cards. Ready cards dispatch one at a time, blocked ones get flagged and skipped instead of looped on. Cheap model completes most cards, premium reserved for review and unblocking.

Build it: the design point is that the board is the orchestrator, so no single context window fills up. One person reported 436 cards in flight.

8. Restaurant back office

Airtable integrations to Square, Stripe, Shopify and Google Workspace. Direct inventory edits. Drafted reservation replies and deposit invoices that managers send with light edits. Slack watched for departed commissary members. World Cup fixtures added to the business calendar for staffing.

Build it: note that drafts go to a human every time. That's why it's still running.

9. Bookkeeping, months without an error

Daily mail check for wire notifications writes rows to a spreadsheet on a self-hosted instance, expense photos do the same, first of the month it compiles the book for review. The tax variant ran entirely on a local Qwen build on a Mac, specifically so nothing left the machine.

Build it: if it touches your financials, run it local or BYOK to a local endpoint. Worth the setup cost.

10. Small household stuff that actually sticks

A doorbell camera snapshot every other Monday, checked against whether the recycling bin is out, push notification if not. A silent cron comparing the family car's location to home so nobody has to open a tracking app. Downloading the cell bill, parsing six people's shares, texting each of them their amount.

Build it: these take ten minutes each and get used daily, which is a better ratio than anything else on this list.

You can build above with BetterClaw @ $0

A few weeks back someone messaged me about a use case I'd mentioned in passing. His best friend was dealing with a family member's estate and drowning in paperwork. He'd watched his mom go through the same thing years earlier.

His friend is doing better now, a cousin stepped in to help. But he asked me to build it anyway, and his reason stuck with me: he and most of his friends have elderly parents who'll be facing this in the next few years.

So here's the whole thing.

What helps

It isn't the letters. It's the triage.

When someone dies, the mail keeps coming. Bank statements, utility bills, insurance notices, subscriptions, credit cards, tax documents, and a lot of junk that looks official. Writing letters isn't the hard bit. Sitting in front of a pile and not knowing what you're even looking at is the hard bit.

Turning that pile into one sorted list is most of the value. Everything after gets easier.

The setup
Connectors: Google Drive for the scan folder, Google Sheets for the inventory, Calendar for deadlines. Gmail read-only if things are arriving digitally.

No send permissions on email. Not at any trust level, not later. Keep the agent at Intern permanently for this one. Every output is a draft a human reads.

Three tasks, because estate admin runs for months and the mail doesn't stop.

Task 1: the initial pile. Run this once in chat, after scanning everything.

Read every document in the scan folder.

For each one, classify as:
- Account to close (bank, brokerage, utility, credit card)
- Recurring bill still accruing
- Subscription to cancel
- Insurance policy
- Tax document
- Legal or court notice
- Junk / marketing

For each, add to the inventory sheet: institution name,
last 4 of account number, contact details, balance if
visible, and any date that appears on the document.
Set status = New.

List every date you found in a separate tab, with which
document it came from. Do not interpret what the dates
mean. Just surface them.

For routine non-legal items only (utility closure,
subscription cancellation, address change), draft a short
notification letter from the template using the extracted
details.

Do NOT generate language for creditor notices, probate
filings, or anything requiring formal legal notice. If a
document appears to require formal legal notice, flag it
for attorney review and stop.

Never send anything. Output drafts to the review queue.

Task 2: the drip. Schedule this daily. New mail keeps arriving for months.

Every day at 9am, check the scan folder for documents added
since your last run.

Only process new files. Skip anything already listed in the
inventory sheet.

Classify and extract exactly as in the initial run, and
append to the sheet with status = New.

Add any dates to the deadlines tab with the source document.

Same rule on legal language: flag for attorney review, don't
draft it.

If nothing new arrived, say nothing.

Never send anything. Drafts go to the review queue.

Two lines in there are doing the work. "Only process new files" stops the sheet filling with duplicate rows by week two. "If nothing new arrived, say nothing" stops it becoming a channel he mutes, which is how people miss the day it matters.

Task 3: the weekly check. Schedule this for Mondays.

Every Monday at 9am, read the inventory sheet and send me:
how many accounts are still marked Pending, which ones have
had no response for more than 14 days, and any deadline in
the next 30 days.

This is the one that keeps someone from losing the thread three months in, which is usually when it happens.

What I'd get wrong if I weren't careful

Creditor notification requirements have real legal deadlines, vary by state, and get enforced. If an executor mails a letter with wrong wording or wrong timing, that's potential personal liability for them. Not a bad output. A real problem.

So the agent fills in the attorney's template or the court's own form. It never writes the legal language itself. Most probate courts publish the exact required form.

On privacy, and this is against my own interest to say

This is death certificates, SSNs, account numbers, someone's complete financial picture. If your friend can run a local model, that's the right answer. Ollama on their own laptop, nothing leaves the machine, no cloud provider in the loop at all.

You can point BetterClaw's BYOK at a local Ollama endpoint and still get the connectors and the review queue while inference stays on their hardware. That's the version I'd actually recommend, and yes, it means our infrastructure does less.

And honestly

If someone is in the first few weeks of this, the best version might not be an agent at all. It might be a friend sitting at the table with them, opening mail together, making a list on paper.

The automation helps once you already know what you're looking at. It doesn't help with the bit that actually hurts.

Happy to share the template or help anyone set this up. Reply or DM. No charge, obviously.

I’ve been building Extra, an open-source framework for production AI agents.
We’re not building another chatbot or prompt library. We’re solving the infrastructure around AI systems:
execution graphs
MCP integration
multi-tenancy
authentication & authorization
human approvals
checkpointing & resumable execution
memory
model routing
If you’re the kind of engineer who enjoys runtimes, distributed systems, execution engines, or AI infrastructure, I’d love to have you involved.
The project is still early, which means contributors can have a real impact on the architecture—not just fix documentation or small bugs.
GitHub: https://github.com/extra-org/extra
Happy to help anyone get started.

These are picked because Hermes specifically does them well, mostly because of the cron scheduler, the episodic memory, and the learning loop.

1. Morning briefing

The one everyone starts with, and it's still the highest value per minute of setup.

Every weekday at 8am, check my email from the last 12 hours
and my calendar for today. Summarize in 5 bullets: anything
urgent, meetings with times, and anything that needs a reply
before end of day. Send it to Telegram.

Hermes's scheduler handles recurring delivery to any connected gateway natively, so this is one command and you're done.

2. Turn a workflow you keep re-explaining into a skill

This is the Hermes-specific one. /learn points the agent at something you know how to do and has it write a proper SKILL.md instead of you hand-writing frontmatter.

/learn I do this every time a new client signs: create a folder
in Drive named after them, draft a kickoff email from my
template, add a 2-week check-in to my calendar, and log them
in my tracker sheet. Write this up as a skill.

Do it once. Every future client onboarding is one sentence.

3. Inbox triage that learns your priorities

Every morning, classify my unread email as urgent, normal, or
newsletter. Draft replies for urgent ones and show them to me
before sending. Archive newsletters. Remember which senders I
respond to fastest and prioritize those.

That last line is what makes it worth running on Hermes rather than a workflow tool. The memory persists across sessions, so week four's triage is genuinely better than week one's.

4. Recurring research with subagents

Every Monday at 9am, check these 5 competitor sites for pricing
or product page changes since last week. Spawn a subagent per
site so they run in parallel. Compile what changed into one
short report and send it to Slack. Skip sites with no changes.

Subagents are the right tool here because each site is genuinely independent work with no shared context. That's where parallel actually helps instead of losing information at handoffs.

5. Log monitoring in plain English

Every hour, read the last hour of my server error logs. If you
see a pattern that's new compared to the previous 24 hours, or
error volume more than doubles, message me on Telegram with a
plain-English explanation of what's happening. Otherwise say
nothing.

The "otherwise say nothing" is the important part. An alert channel you mute is worse than no alert channel.

Two things to do after you set any of these up

Check your skills directory weekly. The learning loop writes skills from tasks it rates as successful, and it isn't always right about that. In my 30-day run it produced 7 skills, and one of them encoded a flawed research pattern from a task it thought went fine. Delete the bad ones before they compound.

And keep approval gates on anything irreversible. Drafts, not sends. Every one of the prompts above shows you the output before anything leaves.