The Free Agent that Runs on Everything
22/05/2026
I am not trying to cancel AI subscriptions because I suddenly became disciplined with money. I'm cancelling because they are portable.
I think this is the better take on the whole thing: the Free Agent that runs on everything.
That sounds like I am trying to be clever with branding, which is always a bit dangerous because I am absolutely capable of making something sound worse by naming it. But this one keeps sticking in my head because it is not only about saving money, even though the money part is obvious and very annoying. Claude Code at $160 AUD a month, Cursor at $36 AUD, Gemini at $36 AUD. That is over $200 AUD a month before I have even started talking about the other little AI subscriptions that sneak in and pretend they are harmless because they are only $10 here or $20 there.
I am not trying to cancel AI subscriptions because I suddenly discovered frugality and discipline. That would be a lie. I am trying to cancel them because the good bits are starting to become portable and free, and once you see that, the whole subscription pile starts to look a bit stupid.
The useful part of Claude Code is not really the subscription. It is the coding loop, the project context, the ability to sit inside a repo and actually do work. The useful part of Cursor is not really the editor branding. It is that the model can see enough of the codebase to stop acting like a chatbot trapped behind a textbox. The useful part of Gemini is not another tab with another personality. It is cheap model access, long context, background thinking, and occasionally doing something weirdly useful when the other models are being precious.
The Free Models I have routed to pi agent. 1.1-billion tokens
Those things matter. I am not pretending they do not. I still want frontier models. I still want powerful coding agents. I still want the stupidly good image models and the occasional magical moment where an LLM does in three minutes what would have taken me half a week. I just do not want the entire workflow trapped inside five separate apps that forget me the second I leave.
That is the bit that changed for me with Hermes. Hermes did not feel different because the model was magically smarter. It felt different because memory and skills started compounding locally. It remembered that I hate bloated SaaS spacing and generic AI copy. It knew where my projects were. It stopped needing the same argument every session. And all of this within 3-5 days. That is a much bigger deal than it sounds, because most AI tools still behave like I have never spoken to them before unless I manually drag a pile of context into the window and hope it behaves.
The agent I actually want is not one more subscription. It is a workflow layer that can run whatever model makes sense, use local tools, pull in skills, browse when needed, scrape when needed, write files, test things, and carry memory across the whole mess. Sometimes that might mean GPT-5.5 or Claude or whatever frontier thing is winning this week. Sometimes it might mean a local Gemma model doing boring background work. Sometimes it might mean Pi.dev through FreeLLM for automation I do not care enough to spend premium tokens on.
Something like this, basically:
orchestrator: Hermes
memory: local profile, project rules, writing voice, workflow scars
workers:
- Pi.dev through FreeLLM for cheap background automation
- local Gemma 14B for throwaway reasoning and drafts
- frontier model (Hermes) only when the task actually deserves it
tools:
- browser-harness/Pi Skills for live pages
- reusable skills for scraping, writing, testing, design, finance, whatever
- Open Design style rules for frontend taste across agents
- local files and scripts instead of everything being trapped in a SaaS UI
workflow:
- Kanban Boards
- Multi Agent Orchestration
- 24hr Cron Job backup to git for Hermes and Pi Brains
That is not a polished architecture diagram. It is more like a scribble on the back of a receipt after getting annoyed at another billing email. But the shape feels right. The model stops being the product. The app stops being the prison. The agent stack becomes the thing that belongs to me.
FreeLLMAPI is interesting in that context because it claims roughly 1.3B routed tokens per month by cycling free usage through mainstream models. I have not proven that under real pressure yet, so I am not going to pretend it is solved. It might fall over. It might be annoying. It might be one of those tools that looks amazing on GitHub and then immediately reveals a dozen miserable little edge cases the second you build a workflow around it. That happens constantly.
But even if it is only half useful, it points in the right direction. The direction is not "free tokens are magic". The direction is routing. The direction is being able to say: this job is not worth premium model money, this one is, this one can run locally, this one needs browser access, this one needs memory, this one needs a skill I already wrote three weeks ago when I was furious about the same problem.
This is also why Browser-Harness and Pi Skills matter more than they probably look from the outside. Paid scraping APIs are useful, sure. Firecrawl and similar tools exist because scraping the web is a swamp full of broken markup, bot checks, waiting states, weird redirects, and pages that only exist after a pile of JavaScript has finished doing whatever the hell it is doing. I get why people pay for that.
But if the workflow owns the browser, owns retries, owns the skill, and owns the output shape, a lot of that paid dependency starts to look replaceable for normal work. Not all of it. I am not claiming some weekend script beats every polished service. I am saying the agent stack gets much stronger when the scraping knowledge lives in my workflow instead of being rented from another API that may or may not understand what I actually wanted.
The difference is tiny at first. A command like this does not look like much:
BU_CDP_URL=http://127.0.0.1:9222 browser-harness <<'PY'
new_tab("https://example.com")
wait_for_load()
print(page_info())
PY
But that shape is powerful because it can be wrapped in a skill. The agent can learn the pattern. It can retry. It can inspect the page. It can save the useful bit back into the vault. It can stop reaching for another paid tool every time the browser is involved. That is the boring stuff that compounds. Nobody gets excited about it on launch day, but six weeks later it is the difference between feeling like you are building a system and feeling like you are paying rent to a dozen tabs.
Open Design hits the same nerve from a different angle. Claude has generally had better frontend taste than the other agents, at least for the kind of work I keep asking them to do. Codex can code like a weapon, but if you ask it for UI without guardrails it can still wander off into weird spacing, safe gradients, huge cards, and that fake startup glow that makes everything look like it came from the same AI landfill. Claude Design was impressive because it had taste, or at least enough taste to stop me yelling at the screen immediately.
Open Design is interesting because it tries to pull that taste out into something other agents can use. That is the pattern again. Take the useful part out of the product. Turn it into portable knowledge. Make it available to Codex, local models, Hermes, Pi, whatever comes next. If design taste can travel, scraping can travel, memory can travel, and workflow rules can travel, then buying another AI app starts feeling like the least interesting option.
This is the prompt shape I want tools and agents to understand more often:
Use the cheapest capable path first.
Only spend frontier-model tokens when the task needs judgement, codebase-level reasoning, or voice fidelity.
If this task matches an existing skill, use the skill instead of improvising.
If the browser can solve it locally, do not assume we need a paid scraping API.
If the result teaches us something reusable, save that as a skill so we do not pay the same thinking tax again next week.
That last line is the bit I care about most. Paying for AI tools is not the enemy. Paying repeatedly for the same context loss is. Every time I open a fresh tool and have to explain my project, my taste, my folder structure, my writing voice, my hatred of generic UI, my weird local setup, and the thing we already learned yesterday, I am paying in a different currency. Time, attention, patience, whatever. It is still expensive.
Hermes started feeling like a teammate because it reduced that cost. It did not make AI perfect. I still have to check things. I still have to catch bad assumptions. I still have to tell it when something sounds like LinkedIn sludge. But the work is starting to accumulate somewhere I control, and that is the part that makes the whole thing feel less exhausting.
The subscription apps are all trying to own the same layer. They want the editor, the chat, the memory, the project context, the tools, the automation, the workflow, the billing relationship, and probably my soul if the terms of service update is written creatively enough. That makes sense from their side. Lock-in is valuable. If your agent memory, skills, and workflow history live inside one vendor, leaving becomes painful even if the next model is better.
I do not want that. I want the Free Agent that runs on everything.
Free as in cheaper when possible, yes. I am not above caring about $200 AUD a month. But also free as in portable. Free as in model-agnostic. Free as in it can use a local model, a routed model, a paid frontier model, a browser, a shell command, a skill, a repo, a vault, or some ugly little script I wrote at 1am because the clean solution was taking too long.
There is a version of this that becomes a mess, obviously. A pile of half-working local tools can be worse than paying for one good product. I know that because half my hard drive is basically a museum of unfinished ideas and "this will be useful later" folders. So the answer is not to romanticise open source glue code and pretend everything free is noble. Some free tools are crap. Some paid tools are worth every cent. Some local workflows become a maintenance burden because you were too stubborn to pay someone else to solve the boring part.
But the direction still feels right. One strong orchestrator. Portable skills. Local memory. Cheap routing. Browser control. Frontier models when they actually earn the spend. A workflow layer that gets better because it belongs to me, not because a SaaS app added another sidebar icon and called it an agent.
Maybe the actual AI product is not the model. Maybe it is the workflow layer that remembers how you work and does not reset every time a billing cycle ends. The cheaper bill is nice, but it is not the main prize. The main prize is not having to rebuild yourself inside every new AI app just because this week's benchmark chart moved again.