How Acyclic Scales Agent Swarms Without Scaling Its Web Bill
At a glance
- Company: Acyclic Labs (YC F26), open-source infrastructure for running agent swarms that make complex, long-running work faster and cheaper
- Use case: Deep research, where a swarm of agents searches and reads hundreds of sources in parallel, traversing a fraction of the internet in minutes to surface all the information related to a coding task
- Why TinyFish: Cost per run. A single swarm can make close to a thousand web calls
- TinyFish products: Search, Fetch
- Headline numbers: One prompt, 19 agents, 977 web calls, a reviewed report citing 68 sources in 5 languages, 12.5 minutes, $2.52 total
How Acyclic showed up on our radar
A few weeks ago we noticed one team running a lot more through Search and Fetch than almost anyone else, and when we looked closer it was Acyclic, a two-person YC F26 team out of London building infrastructure for agent swarms. So of course we wanted to know what they were doing with all those calls, and the answer turned out to be one of the most fun ways we've seen TinyFish used so far.
What Acyclic is building
The idea behind Acyclic is that you shouldn't have to sit around while one agent works through a big task step by step. You give it one task, a root agent plans the work and forks a bunch of child agents that run in parallel, each in its own isolated environment. The part we really like is how flexible the swarm is. If a child agent realizes its piece is bigger than it looked, it can spawn helpers of its own, so the swarm kind of grows into the shape of the problem as it goes.
It's meant for work that's too wide for one agent to do well, like research across hundreds of sources, or document-heavy jobs like reading 40 payer contracts and checking 20,000 remittance lines against them.
Ram Vinjamuri (CEO) and Varun Latthe (CTO) met at Cambridge, where they were researching ML and compilers that parallelise code automatically, and then both went off to build multi-agent systems in production, Ram at Palantir with pharma clients and Varun at Tracelight. The agents were already good enough to do the work, and what kept bugging them was why they couldn't just run thousands of them at once. Acyclic is their answer to that.
Why a swarm is hard on your web bill
Research is Acyclic's biggest web workload, and it's where you feel the cost of a swarm first. One agent researching a topic might make a few dozen searches, while a swarm makes hundreds, because every researcher agent is off searching and reading its own slice of the problem at the same time. In the run we'll walk through below, that came to 977 web calls for a single prompt.
That's a funny spot to be in when your whole bet is that more agents in parallel means faster and cheaper work, because with per-call pricing every agent you add makes the web bill bigger. Acyclic had been using other search APIs and they worked fine, but the cost was slowly turning into the thing that decided how wide a swarm could actually go.
Why they moved to TinyFish
The Acyclic team was pretty straightforward about this one: it was the price. Once the web stopped being the expensive part of a run, they could let a swarm fan out as wide as the task needed instead of rationing searches across agents, and switching over was basically instant.
“For research, TinyFish has been the most cost-effective search and fetch we’ve used. That matters when one prompt turns into 19 agents and nearly a thousand web calls.”
Acyclic Labs
What one prompt actually looks like
This is our favorite part. Acyclic gave its swarm a single prompt asking for an investor briefing on grid-scale battery storage. The root agent split the work across 14 researcher agents, and partway through, the agent covering the UK decided its piece was bigger than expected and spawned two helpers of its own. Once the research came back, a writer agent drafted the briefing and a reviewer agent checked it, so 19 agents in all.
Between them they made 410 searches and 567 page fetches through TinyFish, and the final report cited 68 sources in 5 languages. The whole run took 12.5 minutes and cost $2.52 total, which for an investor briefing is kind of wild.
TinyFish also sits under Acyclic's benchmarks. They test every swarm against a single agent and a small team of agents on the same task, on benchmarks like FRAMES and BrowseComp, and that adds up to a lot of web calls too: about 8,300 across 211 benchmark runs in two days.
Where TinyFish sits in the swarm
TinyFish is the web layer every agent in the swarm shares. Each child agent searches with Search, reads what it finds with Fetch, and passes what it learned back up the tree, and the root agent never has to think about how many researchers are hitting the web at once.
Everything that makes it a swarm stays with Acyclic, from how the work gets split to when an agent spawns helpers and how the results get merged and reviewed. They're also clever about tokens, putting a frontier model at the root (which plans the work and writes the final answer) and cheaper models on the child agents doing most of the searching and reading. And they push as much of the scaling as they can outside the model, so the swarm gets as close to real time as possible.
| Need | Acyclic | TinyFish |
|---|---|---|
| Split one task across many agents | Root agent plans and forks child agents, each in its own isolated environment | — |
| Find sources for each slice of the research | Each researcher agent decides what to look for | Search returns current sources for every agent in parallel |
| Read those sources | Agents pull out what matters for their slice | Fetch turns pages into clean content |
| Keep cost down as the swarm grows | Frontier model at the root, cheaper models deeper in the tree | Pricing that holds up at hundreds of web calls per run |
| Deliver one answer | Writer and reviewer agents merge and check the result | — |
Key outcomes
- 977 web calls in a single run, 410 searches and 567 fetches, from one prompt
- 19 agents, 12.5 minutes, $2.52 for a reviewed investor briefing citing 68 sources in 5 languages
- ~8,300 TinyFish calls across 211 benchmark runs in two days
- 0 of 406 web calls failed on rate limits in one benchmark round, with retries handled on Acyclic's side
- Drop-in switch, effectively instant
What they'd tell another team
The Acyclic team had two bits of advice. If your agents make a lot of web calls, run a real workload through and look at cost per run rather than cost per call, because per-call numbers hide how quickly a swarm multiplies them. And if you fan out wide, plan for the per-key rate limit early. They handle retries on their side, and in one benchmark round that meant none of their 406 web calls failed on rate limits.
What's next
Acyclic is building more research swarms on TinyFish and doing a lot more benchmarking, comparing swarms with single agents and small teams across more tasks, and we can't wait to see how wide they take it. If you're running agents in volume, go check them out at acyclic.dev.
Building agents that need to read a lot of the web, fast?
AI disclosure
Content on this website may be created or refined with the assistance of AI tools and is subject to human editorial review.
