300,000 Users and the Outcome Era

This week TinyFish crossed 300,000 users, in the same few weeks that millions of people met Meta's Muse and OpenAI's Dots and learned what it feels like to hand AI a job. You describe an outcome, and the agent takes it from there: it gets its own computer, searches, reads, works its way through websites and applications, keeps going after you close the laptop, and comes back when the work is done. Anyone who has felt that will walk into the office the next morning carrying a simple question.

Where is my Muse at work?

Every enterprise is about to hear some version of it. We reached 100,000 users in September, 200,000 eighteen days later, and the next 100,000 in about a week. The speed is pleasant to report, though I choose to focus more on the timing, because the curve steepened just as the market changed its mind about what AI is for. I've been calling what comes next the Outcome Era: a period in which the thing people pay for is the finished task.

The waterline moved

For the last few years, progress in AI meant better answers. Models reasoned more deeply, context windows grew, and we graded each release by how impressive its response looked. Most people go to work to get something done, though, and what they actually ask for sounds like this: find every company that matches these criteria, research them, log into the systems where the data lives, compare what changed since yesterday, update the record, keep watching, and tell me when something matters. Each of those is a job, and every job has a finish line.

Once consumers grow comfortable handing jobs to personal agents, the expectation follows them to work and reprices everything beneath it. Search matters more than it ever has, and so do fetch, browsers and models, yet all of them become primitives inside a higher abstraction. An agent working toward an outcome judges itself by whether the job got done; the seventeenth search, the forty-second page and the sixth browser session are steps along the way. The waterline has risen from intelligence to execution.

What lies beneath 300,000

At 100,000 users, the preceding thirty days had 57.6 million Search requests, 23.9 million Fetch requests and 1.57 million MCP tool calls. By 200,000, Web Agent usage had grown nearly sixteenfold in three weeks, and if you added up the hours those agents spent driving browsers, TinyFish had done roughly six years of browser work in twenty-one days. At 300,000, the last thirty days show 83.8 million Search requests, 46.9 million Fetch requests covering almost 87 million URLs, 1.46 million agent runs and more than 450,000 browser sessions.

That run total flattens a month that never stopped accelerating. Our day-over-day growth in the last week has been in the high single digits. Daily volume climbed through the whole window; we now run nearly 100,000 agentic jobs a day as a matter of course. Each of those jobs is a reasoning loop that searches, reads, navigates, decides, fills in forms, recovers when a page shifts beneath it, checks its own work and carries on. A typical run takes dozens of steps, and the long ones routinely pass a hundred. Taken together, the logs read like a record of machines doing sustained work.

The agent as customer

Inside those numbers is a second change, and I would rank it alongside the growth itself.

For most of the history of infrastructure software, a developer chose the API and wrote the call. Someone picked Stripe or Twilio or AWS, wired it into the application, and from then on the software called what had been chosen for it, the same way every time. Agents rewrite that arrangement. The developer still decides which capabilities an agent may use, and within that boundary the agent decides which one it needs, when, how often, and whether the result is good enough to go on.

Follow a single request. A person asks their agent for an outcome, and the agent decides to search. It reads the results and decides to fetch a handful of pages. It finds that what it needs sits behind a login, so it starts a browser agent, which works through dozens of steps before handing control back. The developer made TinyFish available; the agent decided when and how to use it. In little over a month, 18 million MCP tool calls have reached us this way, from ChatGPT, Claude Code, Claude, Cursor, Codex, OpenCode, Grok and a long tail of other agents and harnesses, each one a moment when an agent, halfway through a task, reached for TinyFish.

A growing share of the people who benefit from TinyFish have never typed our name. Their agents made the call, which hands infrastructure a strange new customer: the agent itself. It is a demanding one. Your homepage, your brand campaign and the argument your API won on Twitter are invisible to it. It weighs whether a capability is there, whether it works, how quickly it answers, what it costs, and whether it brings the outcome closer.

We are early in understanding how much this changes the way infrastructure finds its users, though the order of things is already clear. Humans choose the outcome. Developers choose the capabilities on offer. Agents choose the tools. Infrastructure does the work. In time, the best infrastructure will be the infrastructure agents reach for most often once they are free to choose.

Who owns the outcome layer

The frontier labs will bring these experiences into the enterprise, and they should. Meta may build Muse for work, OpenAI will push Dots further into it, and Anthropic, Google and every serious model company will ship an agent that can take a job and run. Enterprises will use all of them. The moment those agents move from helping employees to doing the enterprise's own work, though, a larger question surfaces: who owns the outcome layer of the company?

Consider an insurer. A general-purpose agent can browse a claims system, but the agent that processes a claim has to know how that particular insurer works: what counts as sufficient evidence, which state regulations apply, when the fraud rules fire, what it may approve on its own, when a human must step in, and how every decision gets audited. In healthcare, an agent working a prior authorization moves between the EHR, a payer portal, the clinical notes and the open web, carrying patient context through the workflow, only the context it is permitted to carry, under policies that belong to that organization alone. Even accounts payable, the plainest work in the building, asks more than it appears to. Opening the invoice is trivial. The useful agent finds the purchase order, reconciles the discrepancy, checks the vendor against internal systems, asks why the bank details changed, contacts someone when it must, applies the approval policy, and decides whether the invoice is ready to pay.

Work like this is how a company operates, and some of it is how a company wins. An insurer that settles a claim in four minutes where it once took four days has rewritten its cost structure. A bank that runs its compliance checks continuously has changed its risk profile. An accounts-payable agent that resolves most exceptions on its own has redrawn the economics of the back office. A company guards capabilities like those the way it guards its balance sheet.

Sovereignty

Privacy is the obvious reason enterprises will want control, and sovereignty is the deeper one. Who controls the agent that acts for the company? Where do its credentials live, and who decides which systems it may enter and what it may do there? What information may leave the building, which decisions need a human, and where does the audit trail sit? What happens when the agent fails? Who owns the institutional knowledge that accumulates inside its workflows?

The question that matters most comes last: can the company change the intelligence underneath? GPT may suit one part of a job, Claude another, Gemini a third and TinyFish Mako the work on the web, and six months from now every one of those choices may change. That is as it should be. Models will keep getting better and cheaper, and an enterprise ought to collect each gain without rebuilding the system that runs its business. If agents become the way work gets done, I find it hard to picture a sophisticated enterprise letting its entire operating layer become permanently synonymous with a single model company. It will want its workflows, context, permissions, credentials, policies, economics and audit trail to remain its own, along with the freedom to choose the intelligence beneath them. In a word, its outcome layer.

Building an assistant from scratch makes as much sense as writing your own database. Companies will use Muse and Dots and whatever arrives from OpenAI, Anthropic, Google and firms not yet founded. They will buy horizontal agents, build vertical ones, adopt the specialized agents their software vendors ship, and embed outcome agents in their own products. The power to act on the enterprise's behalf is too important to belong to any one of them. The enterprise has to own its outcome layer.

Why I would rather be TinyFish

I'd love to tell you we saw Muse and Dots coming; my team would correct me in public within the hour. What we spent the last few years building is every piece a finished job requires, and this moment happens to require all of them at once. Several of those pieces answer the sovereignty questions as well: Vault and Profiles govern credentials and context, Mako keeps the economics predictable, and the harness can hand each step to whichever model suits it.

Take one job: find every logistics company in Southeast Asia that opened a warehouse this year, confirm each against filings and local news, check which already sit in the partner portal, and flag the next one when it appears. Search finds the candidates, and Fetch reads the filings and the coverage. The portal sits behind a login, so a browser agent draws a session from a warm pool of cloud browsers, with proxy rotation, stealth and session management already in hand, and signs in through Vault under the Profile of the person who owns those partners. Mako makes the dozens of reasoning steps cheap enough that the system holds up when the list runs to four hundred companies. The harness binds it all together, reasoning, acting, observing, recovering when a site redesigns overnight, checking the result, and returning next week to look again.

Seen from inside one job, Search, Fetch, Browser and Agent read as stages of a single execution system, one that loops differently depending on the shape of the outcome: TinyResearch when the work needs depth, TinySet when it needs breadth, TinyMonitor when it needs to keep watch after you leave, TinyEnrich when partial information has to become usable context. Every one of them begins from the same instruction. Tell us what needs to be true when the work is finished.

The unit of value moves up

The market for search, fetch and browsers will keep growing, and fast. Agents will search more than people ever did, read more pages than any person could, and operate more browsers than any human workforce. The buyer of an outcome, meanwhile, judges three things: whether the work got done, how reliably, and at what cost. The old internet measured pageviews, the API economy measured calls, and the model era measured tokens. The Outcome Era will measure completed work.

That leaves TinyFish in a position both enviable and uncomfortable, because our own standard rose with everyone else's. Excellent search stopped being enough, and so did excellent fetch and a capable browser agent. The destination is visible to everyone now: frontier labs are moving toward outcomes, search companies are adding agents, browser companies are adding reasoning, and agent companies are adding search. Being early to the word "outcome" buys a few months of attention.

The lasting advantage lives in the handoffs. Search has to become Fetch, Fetch has to become Browser, Browser has to become Agent, the agent has to work inside a Profile and Vault, the harness has to hold through a hundred steps, Mako has to keep the economics sane, and the infrastructure beneath all of it has to run at a scale an enterprise can stake its operations on, while leaving that enterprise free to choose the intelligence, assistants and applications above us.

That is the opportunity. It is also the threat.

300,000

The first 100,000 told us developers wanted what we were building. The second showed how quickly distribution moves once TinyFish becomes infrastructure beneath other agents. The third arrived at a more interesting moment, as millions of people handed software a job for the first time and watched it come back finished.

They will carry that expectation to work, and every enterprise is about to hear the same question. Where is my Muse at work? The answer could be Muse, or Dots, or an agent they buy, or one they build, or dozens spread across the company. Whichever it turns out to be, the outcome layer has to stay theirs.

We want TinyFish to be the infrastructure that lets them own it.