TinyFish, a startup co-founded by a former Meta engineering leader and reported to have raised $47 million, grew from zero to more than 400,000 users in under twelve months. The company credits that growth to a single shift in thinking: it stopped designing its product only for people and started treating AI agents as the customer. That decision changed how it bills, how it onboards, and how it exposes its capabilities. The result is a case study in what a business looks like when the entity choosing, paying for and using a service is software acting on a human's behalf.
What TinyFish sells
TinyFish provides an API that lets AI agents search the web, fetch pages, log in to accounts and complete multi-step tasks such as filling out forms. The platform exposes three sub-tools: a Search API, a Fetch API and an autonomous Web Agent tool. A user can connect these to a conversational assistant such as ChatGPT or Claude, which then calls TinyFish whenever it needs to act on a live website.
The company has demonstrated the flow end to end. A prompt submitted to ChatGPT on behalf of a mock company called ACME Corp asks it to find TinyFish's pricing and then submit the sales contact form. ChatGPT first calls the Fetch API to pull current pricing tiers and usage limits. It then invokes the Web Agent tool, which opens a remote cloud browser, finds the intake form, enters a name and corporate email, opens drop-down menus, checks a consent box and submits. The task completes in 60.8 seconds across 10 steps. In a second demonstration, a stored browser profile logs the agent into an authenticated developer dashboard to chart search latency across the last 20 runs, reporting an average of 1.522 seconds, a median of 1.40 seconds, and 80 percent of runs finishing under 2 seconds.
When the customer is an agent, the pricing model changes
The most concrete business lesson from TinyFish concerns monetization. A conventional software product charges a human roughly $20 per month. That model assumes a person with a credit card who signs up, reads a pricing page and commits to a recurring plan. An autonomous agent cannot do that easily, and it often needs only one small job done.
TinyFish replaced the subscription with a prepaid consumption wallet. An agent can authorize a microtransaction of around 40 cents to complete a single discrete task, with no human stepping in to approve each purchase. The company describes this as part of a broader philosophy it calls Agent Experience, or AX, which treats agents as primary end users alongside humans.

▲ Subscription billing versus per-task wallet payments
The growth curve reportedly took off after the wallet launched in late August, in the same window that TinyFish deployed its own web-native model. That model is said to have cut operating costs by a factor of 10 while improving speed and success rates, which makes 40-cent tasks economically viable in the first place.
| Billing approach | Who buys | Unit | Typical price |
|---|---|---|---|
| Monthly subscription | A human with a card | A month of access | $20 |
| Prepaid wallet | An agent acting for a user | One task | About 40 cents |
The comparison above reflects the two models as TinyFish describes them, not industry averages.
Letting agents sign themselves up
Pricing is only half of the agent-as-customer problem. The other half is onboarding. TinyFish built an Agent ID system and a service called Agent Mail so that an agent can create an account, generate and extract API keys, and configure Model Context Protocol (MCP) integrations without a person in the loop. MCP is a standard that lets AI models discover and call external tools; TinyFish packages its web capabilities as MCP tools so other agents can find, evaluate and invoke them.
The reasoning is that multi-agent workflows are emerging in which one agent provisions tools for itself or for other agents. If a human has to click through a signup form and paste an API key, that workflow stalls. The company also argues that clear public pricing and visibility in independent benchmarks matter, while noting that execution quality itself cannot be gamed.
How the agent works under the hood
TinyFish grew out of an earlier open-source project, AgentQL, that its co-founder's team built after a weekend experiment at Meta. The experiment connected an early GPT model to Playwright, a browser automation tool, and asked it to book a flight. The model got surprisingly far, but early language models lacked built-in tool calling and had small context windows, so the team first built AgentQL as a semantic data extractor: it turned raw HTML into structured output using natural-language queries instead of fragile CSS or XPath selectors.
Several engineering choices from that period still shape the product:
- Codification. On first contact with a page, the system records and triangulates several attributes of each element it locates. On return visits it reuses those cached paths, skipping roughly 90 percent of model calls even when styling or CSS classes change.
- Gemini Flash for reasoning. As frontier models matured, the team concluded it no longer needed the largest models for routine navigation and moved to Google's Gemini Flash for its mix of throughput, price and HTML comprehension.
- ADK as the harness. Adopting Google's Agent Development Kit, which supplies thought history, structured reasoning loops, observability and execution hooks, reportedly lifted task completion by more than 20 percent on open agent benchmarks without changing any model weights.
- A proprietary model. Production traffic generated a large set of agent trajectories. TinyFish used them to fine-tune an open-weight 35-billion-parameter base model, which now handles most of its workloads.
- DOM over pixels. Rather than screenshots, the cloud browser captures the Document Object Model (the structured tree a browser builds from a page), prunes it and feeds it to the reasoning model, which returns a browser command and adapts to layout shifts. Pixel-based "computer use" models are described as better suited to desktop apps such as Adobe Photoshop.
Evaluation is handled with custom infrastructure that records and deterministically replays browsing sessions. A human annotation team grades whether element selection and intermediate reasoning were correct, and that feedback flows back into fine-tuning.
Trust, identity and safeguards
TinyFish frames user trust as its most important competitive frontier, more important than competing with large AI labs. The analogy offered is autonomous driving: people take their hands off the wheel only after the system crosses a clear reliability threshold. For web agents, the equivalent is letting an agent file a tax return or operate inside a banking account. The company says hundreds of thousands of users already store credentials in its vault so agents can work behind logins, and roughly half of enterprise workloads run behind authentication walls.
Several mechanisms support that trust:
- Authenticated sessions come in two forms. A Vault integration connects to password managers such as 1Password so credentials reach the cloud browser without appearing in plain text to the language model. Browser Profiles store session cookies so agents can operate in accounts protected by multi-factor authentication without repeated login prompts.
- A separate safeguard model inspects every intended action, including the target element and context, before execution and halts the session if it judges the action malicious, unauthorized or financially risky. It is built to add negligible latency. Users can then review a step-by-step screenshot replay and approve or redirect. The company says it tunes this model conservatively by default and acknowledges that acceptable risk varies by enterprise.
- Stateless privacy. TinyFish does not store user history or build profiles; memory and preferences stay in the host agent such as ChatGPT or Claude, which the company says simplifies GDPR compliance.
- A proposed "TinyFish Passport." This identity mechanism would cryptographically tie each action to both the platform and the responsible human, so a destination site could verify who an agent is and whom it represents. The company argues liability cannot rest on users alone and that an ecosystem alliance including Stripe, Visa, Cloudflare and third-party agent builders is needed.
- No CAPTCHA bypassing. Despite customer requests, TinyFish declined to build CAPTCHA cracking or bot-detection circumvention. Its agents stop when they hit a CAPTCHA to respect site terms of service.
An "agent-in-the-loop" protocol is in development that would let a TinyFish sub-agent ask the orchestrating agent or a human for clarification mid-task.
How a founder runs on agents
The agent-first philosophy extends to how the company's product chief works. He runs a remote development server hosting about 12 parallel cloud coding sessions that prototype features concurrently. While traveling between customer meetings, he directs them from a phone by voice; the sessions send progress updates and questions and request next steps. Some run unattended overnight or longer.

▲ Directing parallel coding agents by voice while traveling
Not every experiment ships, but the company reports two to three agent-developed features reaching production each month, which it regards as an excellent result for a small team. It also commits to releasing at least one major capability monthly. One caveat offered is that a product leader writing a lot of code can create friction for the core engineering organization.
The product-management lesson drawn from this pace is that ideas can become redundant within two weeks as frontier models absorb capabilities natively, so product leaders need to forecast two to three months ahead and keep a tight relationship with engineering.
Advice for founders
On customer requests versus roadmap, the guidance is that there is no single rule, but every request should be measured against core infrastructure, long-term vision and resources. Early payment, even $1, is treated as crucial validation that someone values the idea.
The sharper warning concerns a trap: drifting into a services business that bills engineering hours or resells raw cloud model tokens. That model, in this view, prevents a startup from building scalable product value.
Where the web may go next
The co-founder's broader forecast, presented here as a prediction rather than a settled fact, is that the web will flip from blocking bots to courting them. As agents become primary shoppers, hiring a gardener or comparing vendors on a user's behalf, commercial sites may become "agent-certified" and optimize for verified agent traffic. Experience-driven sites such as streaming or fashion would keep rich visual designs, while transactional services would go headless, delivering structured data and transactions directly to agents. Sites that fail to offer machine-readable interfaces could, in this view, lose significant business.
The ecosystem he envisions has two tiers: a handful of consolidated consumer super-agents such as ChatGPT, Gemini and Muse, and billions of specialized agents built by individuals and companies to work with their own data. TinyFish positions itself as infrastructure for the second tier, which is the origin of its name. The frontier beyond that, he suggests, is self-constructing agents that pursue an owner's goals, source their own tools and even request a credit card to buy a subscription they need.
What to take away
The TinyFish case suggests a few practical implications for anyone building or buying software in an agent-driven market:
- If agents will use your product, price in units an agent can buy on its own, such as per-task wallet charges, rather than monthly plans that require a human signup.
- Make onboarding machine-executable, including account creation, key issuance and MCP tool discovery.
- Separate safety from reasoning with an independent check on every action, and define clear stopping rules such as halting at CAPTCHAs.
- Keep credentials out of model prompts by using vault integrations and session profiles.
- Protect the business model by selling packaged software value, not hours or tokens.
The figures here, including the 400,000 users, the 10-times cost reduction and the 40-cent task price, are reported results from one company and should be read as such rather than as outcomes any team can expect.


