TL;DR
- Agents forget everything between sessions (by design).
- With the thinking pre-done, even open-weight models handle tasks that used to need a frontier.
- Browserless' own agents' sessions are distilled into skills, tested by real traffic, auto-retired when they stop working, and published in a free public catalog.
We’ve said it time and time again. The technology behind LLMs is here to stay. Having public and open-weight models that are the equivalent of a supercomputer is one of the greatest engineering milestones we’ll see reached in a long time.
LLMs and agents are remarkably smart. The problem is that they are completely amnesiac. If you have an agent go to Google Flights, it will figure out the datepicker, dodge the consent modal, discover that the search box wants airport codes, and eventually hand you a list of flights. Maybe it took 12 screenshots and burned lots of tokens, but the fact remains that it did it all by itself. Genuinely impressive.
Then the session ends, and everything it learned evaporates. The next agent (maybe yours, maybe someone else's agent, maybe just five minutes later) lands on the exact same page, and has a blank memory of the events that just transpired. Same datepicker, same modal, same fifteen tool calls.
Multiply that by every site on the web and every session ever run, and you're paying frontier-model prices to rediscover the same handful of facts, forever.
The LLM when you ask it to check on your inbox in a new chat
So, if the issue is the agent’s memory, then the solution would be to give it some…
Giving the agent a memory
Or rather, what the industry calls a skill: a markdown file that’s not merely a replay of clicks, but a distillation of the durable knowledge about a site – the URL scheme that skips the whole UI, the hidden JSON blob the page inlines, the anti-bot quirk, a runnable extractor, and all the stuff that stays true between visits.
Take Google Flights, for example. Without a skill, an agent wanders the UI. With the skill, the agent knows that the entire gist is to build one URL, run one goto, one evaluate() to read the itinerary cards, and it’s donezo; the agent doesn’t have to infer the whole web on its own.
And this is where it gets fun. Once the hard thinking is written down, the model executing it doesn't have to be the one that does the thinking. In fact, an open-weight, MCP-capable model can handle site tasks that would normally demand a frontier model, because the skill reduces the job from "explore an unfamiliar UI and reverse-engineer its behavior" to "build a URL, send change events to some selectors, submit a form[action='foo'] and that’s it."
For this, you just need a model that can follow instructions. And almost all of them can.
The bucket that fills itself
Now, the obvious question: who writes all these skills? It depends. If you’re using the browserless MCP server, nobody writes them, but they do get written.
Every agent session that runs through our MCP server is observed: what commands are issued, the URLs it navigated to, the user's original intent, the interaction with the page, and even the time it took.
Then, our system asks "was anything durable learned here, and if so, what's the generalized recipe?"
But we don’t just save anything. We make sure to:
- Raise the bar and only save non-obvious, durable knowledge. "Go to time.is and tell me the time" is not a skill.
- Generalize. We try as much as possible to decouple specific one-off searches into general recipes. So if you search Goodreads for a book, we’ll come up with a skill to find any Goodreads title based on ASIN, ISBN, title, etc.
- Merge the knowledge. If a skill for the task already exists, the new run widens it. If an agent run that used the “list-all-sales” skills now uses a country filter or a sorting option, we save that as durable knowledge.
And it's the self-sustaining loop: agents that use a skill report back whether it worked, skills accumulate success and failure counts, and one that drops below a threshold gets the axe automatically.
Gates, judges, and other boring stuff
A self-sustaining feedback loop that powers a live knowledge base for internet sites needs adult supervision:
- Our system checks every candidate for safety (extractors are not inserting malicious code, no exfiltration, and no credentials) and topicality.
- Provenance on who ran the session that produced a skill is stored.
- Outcome reports are fenced and analyzed, so no stuffing the ballot box.
- Publishing to the public catalog runs a second, stricter judge: an actual meat-and-bones human
And did we mention it's public?
The best part: we're not keeping the bucket to ourselves. Every skill that clears the quality gate is published in a browsable, indexable public catalog, and we already have hundreds of recipes across hundreds of sites, from flight searches to real-estate listings to government forms – each one battle-tested by real agent traffic and demoted the moment it stops working.
Using them requires no installation. Point any MCP-capable LLM at mcp.browserless.io and skills hydrate automatically: land on a site, and the matching recipes are offered to your agent before it starts planning its own steps.
Or fetch them directly:
GET https://production-sfo.browserless.io/skills?domain=google.com&token=$TOKEN
That URL carries your token in the query string, so keep the call server-side and never ship it to a browser or any other client.
Your agent's first day on any site should include having knowledge about how the page was five minutes ago.