Why TinyFish Search is Free

Ask a search engine who ruled Turkey’s capital in 1810 and it will tell you that the capital of Turkey is Ankara, which is not wrong, but is also not remotely the answer you were asking for, because to get to Sultan Mahmud II an agent has to do something much closer to thinking than searching: Turkey did not exist in 1810, so what was the region called then, what was its capital, who ruled it, which source is trustworthy, and what should be asked next based on what it just learned?

That distinction is more important in search right now, because search for a human and search for an agent are not the same product, even though we sometimes talk about them as if they are.

A human can look at ten blue links, decide which one seems credible, open three tabs, ignore two of them, read enough of the third to form a judgment and then continue from there; all of that reasoning happens invisibly inside the person. An agent does not want ten links, it wants the outcome, and every time we force it to stitch together search, fetch, browser, proxy, model calls and session state by itself, we are effectively asking the agent to understand the plumbing underneath the job instead of simply doing the job.

This is the bet behind TinyFish, and it is also the simplest explanation for something that has confused a lot of people recently: why are we giving such a high quality TinyFish Search away for free?

The answer is not that search suddenly became cheap, or that we discovered some magical way of doing expensive work without paying for it. The answer is that we do not think search is where the value ultimately lives.

We think search is becoming a primitive inside execution.

If an agent is trying to book something, monitor something, compare something, fill something out, buy something, reconcile something or operate a workflow on the web, search is simply one of the things it may need to do along the way, in the same way that software uses DNS or storage or networking without asking the application developer to reason about those systems every time the program runs.

The agent should not care which search system found the page, which browser rendered it, which proxy got through, whether a CAPTCHA appeared, how the session was preserved, which model read the page or how many retries it took. It should care whether the job got done.

That is the abstraction we are building toward, and once you see search as one primitive inside that abstraction, free search starts to look much less strange.

We already paid the infrastructure bill

The modern web is remarkably expensive to access reliably, although most of that expense is hidden at first.

The first request works, the second one works, someone puts together a small scraping stack and everything feels easy, and then gradually the real web shows up: JavaScript-heavy pages, bot detection, IP reputation, TLS fingerprints, browser fingerprints, CAPTCHAs, authenticated sessions, dynamic page state, websites that behave differently by geography or account or time of day, and an infrastructure problem that quietly becomes its own engineering organization.

Most companies encounter that cost after they have already decided what product they want to build.

We did it in the opposite order.

Very early in TinyFish, before search and fetch were products and certainly before we thought about giving either one away, we spent an unreasonable amount of engineering effort building the layer underneath all of it: our own browser infrastructure, our own stealth systems, fast session hydration and teardown, elastic infrastructure that can expand aggressively when workloads appear and, just as importantly, contract again when they disappear.

None of this is particularly glamorous, and almost none of it makes for a great demo, but infrastructure economics are often determined by exactly the things nobody wants to demo.

We paid that tax early because we knew that if the cost of accessing and operating the web did not collapse, everything built on top of it would eventually inherit the same bad economics.

Once you have done that work, however, something interesting happens: the marginal economics of search become very different.

That is one part of why we can give it away.

The other part is Mako

Getting a page is only half the problem, because somewhere in a multi-step search the system still has to decide what the page means, what part of it matters, whether the result is trustworthy enough to continue, what should be extracted and, most importantly, what should happen next.

This is where agentic search becomes fragile, because one bad interpretation early in the chain can send every subsequent step in the wrong direction, and the system can do all of that while sounding wonderfully confident.

That is why we built Mako.

Mako is a family of models built specifically around search, fetch, and other agent-native understanding of the web. What separates it from a frontier model is the internet it has seen, not how much of it.

Mako models didn't learn from scraped web text. It has learned from operational trajectories and millions of searches performed by agents, not by humans, on logged-in workflows, click sequences, URL state changing as an agent moves through a site, the strange behavioral texture of the web that appears only when you are operating it rather than crawling it. This distinction is going to matter more over time.

There is an assumption embedded in a lot of AI right now that intelligence compounds primarily by giving models more parameters or more text, and of course both matter, but there is another kind of intelligence that comes from experience, from repeatedly attempting something in the real world, observing what happened, learning which sequence worked and which one failed, and carrying that experience into the next attempt.

Every automation TinyFish runs gives us more of exactly that kind of data: the structural record of how the web behaves under an agent, which pages resolve which questions and which steps depend on which earlier answers, in aggregate, rather than the contents of any one customer's work.

So when a difficult search requires multiple intermediate reads and decisions, we do not have to send every one of those steps through a large frontier model at frontier-model economics; we can use a model purpose-built for the work, running on infrastructure we already operate, and the economics change again.

That is the second reason search can be free.

We are not trying to index the entire internet

The obvious question then becomes: if search matters this much, why not just build the biggest possible index and compete directly with Google?

Because that is not the problem we are trying to solve.

We are not anti-index, but there is a very specific trap in becoming an index company. Eventually, the index becomes the company. You wake up every day having to crawl more of the web, keep more of it fresh, store more of it, rank it better, and justify an infrastructure bill whose logic increasingly determines the roadmap. That can be a great business if indexing is the business you want to be in, but it is not the business we are trying to build.

TinyFish is trying to make agents better at getting work done on the web, and for that, the asset that matters is the accumulated memory of how real work gets done across it. Once you start there, you can still build an index where it helps, but you are not condemned to becoming an indexing company simply because search was your first primitive.

There is another consequence of driving the cost of operating the web down this far, particularly when you decouple that work from frontier-model intelligence and let infrastructure and models like Mako do the work they are actually good at: Jevons paradox begins to kick in. When something becomes dramatically cheaper, you do not simply spend less on it, you start doing much more of it, and that changes how we think about an index itself.

Freshness no longer has to be a fixed architectural commitment where everything is crawled continuously whether it matters or not; it can become a throttle, turned up aggressively for the parts of the web and the relationships in the graph that matter right now, relaxed where they do not, and adjusted continuously as context and demand change. The same is true of the contextual layer around that index, where relationships can be discovered, refreshed, strengthened or allowed to decay based on actual usage. In other words, once operating the web becomes cheap enough, the index stops having to be this enormous static thing you build and then desperately try to keep fresh, and starts becoming something much more elastic, shaped continuously by what agents are actually trying to do.

Agents run workflows, and workflows repeat. They return to similar domains, ask questions with similar dependency structures, encounter the same kinds of pages and move through the same kinds of states, so over time the useful thing is not simply remembering more documents, but remembering how the work itself gets done.

Which queries tend to follow which other queries, which sources actually resolve the question, which paths were productive, which steps can happen in parallel, which ones are dependent on earlier answers, and which portions of the work do not need to be rediscovered every single time.

That is a narrower ambition than indexing the entire web, but for agents I suspect it may be the more important one, because every real execution can make the next similar execution cheaper, faster and more reliable.

We will publish the dependency-graph work separately.

So what is the catch?

There is one, of course, because nobody gives away something valuable without some economic logic underneath it.

TinyFish Search is free at a rate limit that is intended to be useful, well past what it takes to produce a demo, and Fetch is free as well at a lower rate limit because fetching and rendering a page is heavier work and pretending otherwise would be silly.

What we charge for is what happens after knowing turns into doing.

When an agent has to log into an account, navigate a multi-step workflow, fill out a form, maintain a session, monitor something over time, retry when the web behaves unpredictably, verify that the intended action actually happened and safely manage the credentials required to make all of that possible, that is automation, and automation consumes paid credits.

That is the whole logic of the business, because Search is the beginning of the journey, not the destination.

I increasingly think this is the conceptual mistake people make when they look at the emerging search market and ask who is going to build the best search API for agents, because the more interesting question is whether an agent should have to think about a search API at all.

Humans needed search engines because humans were the execution layer. We searched, clicked, read, interpreted,logged in, filled out the form, and we completed the transaction.

Agents change that architecture.

Once the software itself is doing the execution, search becomes one internal operation among many, and the boundaries we inherited from the human web start to look increasingly arbitrary.

Search, fetch, browse, credentials and execution should not be five products that an agent somehow learns to orchestrate on its own, because an agent should no more have to understand proxy rotation and browser fingerprints than a person buying something on Amazon has to understand DNS.

Those things should disappear underneath the abstraction.

One API should be able to find the information, retrieve the page, understand what matters, preserve the necessary context, operate the site and verify that the intended outcome actually happened.

That is what we are building TinyFish to become.

And that is why we can afford to be unusually aggressive about giving search away, because search is not the business we are trying to protect.

The thing we care about is much further downstream: whether the agent got the job done.