Add to Chrome
Here is the defect at the center of every agent product shipping today, including ours: it starts from zero every time.
Retriever booked that appointment for you last Tuesday. It read the calendar, found the modal, handled the timezone picker, recovered from the double-submit. Today you ask again, and it pays full price — in tokens, in latency, in the chance of getting it wrong — to rediscover the same six clicks. Nothing about Tuesday made Wednesday cheaper.
That's the thing we're spending the next year fixing. Not one feature. The shape of the whole product.
Retriever is building the self-improving action layer for the web: an agent system that learns from every task, turns successful experience into reusable software, and gets more reliable, faster, and cheaper as you use it.
The model isn't the agent
An agent is a model plus a harness. The model reasons. The harness is everything else: the tools, the browser skills, the memory, the identity and permissions, the recovery procedures, the routing between providers, the tests that say whether any of it works.
Frontier labs own the model, and they're improving it faster than anyone can keep up with. Good. We're not racing them — we never bet on agents staying bad at navigation.
We're betting on the other half. Because the harness has an advantage the model doesn't: it can learn from your work, on your software, today — without a training run, without waiting for the next checkpoint, without your logged-in portal ever leaving your browser.
The labs are chasing systems that propose changes to themselves, evaluate the variants, and keep what wins. That same loop — generate, evaluate, retain — applies just as well one layer up, to the harness. That's the loop we're building:
prompt → trajectory → verified outcome → compiled skill → regression test → promoted
↑ │
└──────────────── human rescue ────────────────────────────────┘Half of it already ships. Code-as-plan turns model reasoning into JavaScript that runs in a sandboxed harness instead of looping a model over "what do I click next." AI Subroutines replay a recorded task with zero hot-path tokens. Every run already records a full trajectory.
What's missing is the back half: verifying the outcome, compiling the trajectory into a skill worth keeping, generating the tests that prove it still works next month, and promoting it — into your agent, your team's library, or the shared one.
Five pillars, then. They're one system.
1. Agents that get better every time they work
Today Retriever runs your task. Next, it should learn from running it.
- Experience becomes software. A successful run gets compiled into a named skill with typed inputs, a cost estimate, a permission list, and a plain-English procedure you can read. Ask once, automate forever.
- Rescues become skills. When the agent stalls and you take over, that's the most valuable signal in the product. Retriever should diff your correction against the failed trajectory, propose the fix, and generate the test. Every rescue makes the whole workforce smarter.
- Failures become tests. Broken runs become regression cases replayed against every future change, so reliability ratchets in one direction.
- Skills heal themselves. When a site ships a redesign, the agent should notice the skill broke, explore the new UI, propose a repair, run its own regression suite, and ask you to approve the patch — not silently fail at 3am.
- Proactive, not just responsive. Retriever should watch what you actually do and offer the automation before you think to ask for it.
The end state is simple to state and hard to build: every task should make the next task cheaper, faster, and more reliable.
2. The action layer for the web
Search engines indexed what the web says. We're indexing what it does.
Give Retriever a workflow — demonstrate it, or just describe it — and it should hand you back a real, callable action:
check_customer_balance(customer_id)
book_service(customer_id, service, time)
update_candidate_status(candidate_id, status)
submit_vendor_invoice(invoice)Generated contract, browser implementation, permissions, tests, and an API/MCP endpoint. Turn any software into an API — including software you don't own and can't get an API for. That's the long tail where the real work of most businesses actually lives: the county portal, the legacy PMS, the insurance carrier site, the internal tool with three users.
Alongside it, the agent keeps picking up the instruments a competent operator needs — email and phone validation, telephony, image and video generation, document handling, more MCP servers. Those aren't the vision. They're the toolbelt underneath it.
3. Rover everywhere: one business brain, every surface
Your customers won't come to your website first anymore. They'll ask ChatGPT, or Claude, or text you, or call.
Rover is how your business answers from all of them — with one shared brain, not six disconnected bots. Same customer identity, same conversation memory, same policies, same permission scopes, same approval rules, same audit trail, same human handoff, whether the request arrives from your site, ChatGPT, Slack, email, WhatsApp, SMS, or a phone call.
This is the headless website agent thesis taken to its conclusion: your product becomes ambient. Customers ask for an outcome wherever they already are, and you keep control of auth, policy, and execution. No public API required. No rebuild required. One script tag.
We will not ship a channel until it shares memory and identity with the others. "Available on eight surfaces" is worth nothing when each surface forgets what happened on the last one.
4. A living business graph
"More data providers" is the boring version of this. Here's the real one.
Agentic enrichment already writes a fresh waterfall per request instead of renting a fixed template. Next it becomes the agent's perception system — an always-current picture of your customers, prospects, and market:
- Resolve a person or company across fragmented sources, and show the confidence, the source, and how fresh it is
- Re-verify emails and phones before outreach; repair the record when one bounces
- Bring your own provider keys and your own private data into the same waterfall
- Watch accounts for signals that matter — job changes, hiring, funding, new locations, new reviews, pricing moves
- Fold your CRM into the same graph, and keep it clean
- Learn which signals actually led to outcomes, and weight the next recommendation accordingly
The goal isn't finding a contact. It's knowing who matters, when the timing is right, and what to do next — then doing it, within the rules you set.
5. AI employees, and a library everyone makes better
Nobody wants to assemble an agent from parts. They want to hire one.
So we're packaging outcomes: prospecting, front desk and booking, support, onboarding, outreach, revenue recovery, back-office operations. Ready to run, with a live demo, a cost estimate, and the exact list of what it can and can't do.
Underneath, skills compound at three levels:
| Level | What lives there | Who it improves |
|---|---|---|
| Global | Common UI patterns, pagination, modal recovery, booking flows, structured extraction | Everyone, automatically |
| Organization | Your qualification criteria, refund policy, onboarding steps, internal tools | Your whole team |
| Personal | Your tone, formats, recipients, approval thresholds | You |
Eventually you'll be able to publish and sell what you build — but not before skills are versioned, tested, permission-scoped, and measured. A marketplace launched before that is just a prompt library with a checkout button.
Autonomy you can audit
None of the above is worth much if you can't trust it with the keys.
More autonomy has to mean more control, not less: scoped permissions per skill, spend budgets, approval checkpoints on the actions that matter, full replay of everything the agent did, data-retention rules you set, and a human escalation path that carries the whole context. Every paid call estimated and approved before it runs, the way enrichment already works.
As other people's agents start showing up at your business, this becomes the actual product: Retriever is the layer that decides what an agent is allowed to do — and that authority is granted by you, not learned by them.
Roughly how it sequences
Order will move — that's what roadmaps do. The direction won't.
| When | The theme | What lands |
|---|---|---|
| Aug–Oct 2026 | Teach it once | Trajectory-to-skill compilation, skill library, proactive task suggestions, richer tool coverage |
| Nov 2026–Jan 2027 | One brain, every surface | Shared identity and memory across surfaces, unified inbox, human handoff, voice |
| Feb–Apr 2027 | Autopilot | Correction-to-skill, self-healing skills, regression suites and simulation, signal-driven proactive work |
| May–Jul 2027 | The network | Published skill packs, agent-to-business discovery and transactions, delegated authority |
What we're deliberately not building
- Another multi-agent canvas. Boxes and arrows are a crowded, interchangeable category. Our edge is execution across the web that already exists.
- Another chat widget. Rover operates the business. Answering from a knowledge base is table stakes.
- A benchmark race against general browser agents. We'll lose the navigation arms race to whoever has the most GPUs, and it won't matter. Domain procedures, business memory, permissions, tests, and measured outcomes are what actually make an agent usable at work.
- Channel count before shared memory. See above.
- A marketplace before evals. See above.
What this means if you're already using Retriever
This all lands in the product you already have. Improvements to a plan go to everyone on that plan — no separate SKU for the features that make the agent good, no second-class tier for anyone who bought early. Usage still meters what genuinely costs money: models, cloud browsers, proxies, enrichment records, telephony. The intelligence isn't the upsell.
If you've been with us since the extension shipped, you've watched this go from a DOM parser to code-as-plan to subroutines to Rover to enrichment. Each of those looked like a separate launch. They weren't. They were the harness, being built one piece at a time.
Now we connect them into a loop that closes — so that the agent you hire this month is measurably better next month, because of the work it did for you in between.
Retriever is the self-improving action layer for the web. Try it in the extension, in the cloud, or on your own site with Rover. Everything we ship shows up in the changelog.
