gargi_tinyfish
Joined 10 months ago
Joined 10 months ago
I am from tinyfish.ai (web agents + browser infrastructure for autonomous web workflows like navigation, auth, state, operations on the live web). We partnered with Mango Capital to put $2M behind founders building agentic applications on top of it.
Partnered with 15+ companies to give you the entire stack — MongoDB, v0 by Vercel, ElevenLabs, Fireworks.ai, Google for Startups, Composio, and others — providing free credits and direct channels to their eng teams (not their support teams).
The part that might actually interest you:
The application is a working MVP. You build an app, record a demo video of your code running and app working, and post the video publicly on X. (No slide decks please, everyone’s had enough of them).
We're specifically not interested in:
- Chatbots with a nice UI - "AI agents" that make one API call and format the output - Anything that can be built without browser infrastructure
We are interested in apps that do actual labor on the live web — multi-step workflows, real session management, complex UI navigation, and automate ops at scale.
9 weeks, fully virtual, rolling admissions from Feb 17. $2M seed pool, funding decisions made directly with Robin Vasan (Mango Capital).
Do check it out if that sounds interesting: tinyfish.ai/accelerator
Happy to answer questions!
We are the engineering team behind Mino. We are building the infrastructure layer to help developers scale web agents from demo to production.
Here's the problem: Building an agent is easy; scaling it is expensive. Relying purely on inference loops (screenshot → reason → click) creates a flat cost curve.
It never gets cheaper or faster, no matter how many times you run the same task.
What we did: Convergent Infrastructure Mino is a headless runtime designed to optimize agent execution over time.
Instead of executing every run as a blank slate, Mino treats navigation as a convergence problem. As your agent repeats tasks, our infrastructure analyzes the successful execution traces to optimize the path.
Early Runs: Prioritize adaptability and exploration (handling dynamic DOMs/UIs). Later Runs: Prioritize speed and determinism.
The result is an API that warms up like a JIT compiler, becoming faster, cheaper, and more robust the more traffic you push through it.
The Primitive: We expose this as a stateless, async API designed for composition.
Input: URL + Goal (Natural Language). Output: Structured JSON. Concurrency: Fully parallelized.
We’re opening the API to developers today. 50 completed runs on the house.
Please try it out and give us your feedback.
And we are curious to hear what primitives you feel are missing from the current agent stack (auth management, captcha handling, etc.).
the team wrote some details on how they built fetch and browser (search deep dive coming soon). we forked chromium to build a browser where automation runs below the js sandbox. clicks go through the native trusted event path, dom reads happen in native code with zero javascript executed. separately, we built a fetch that renders pages in a real browser and returns structured content. because status 200 with 14 characters of text isn't actually a successful fetch.
details in the posts. browser: https://www.tinyfish.ai/blog/building-a-browser-for-the-agen...
fetch: https://www.tinyfish.ai/blog/production-grade-web-fetching-f...
please do try them out at tinyfish.ai, 500 credits are on us.