🚨 Multi-Agent - Lite Agent Swarms - Optimize Cost On Large Agentic Loops

After a lot of experimentation we have open-source AI agent swarms live!!

- Opus 4.8 and GPT 5.5 do the planning - Deepseek flash and Gemma do the work - Perfect for multiple parallel tasks - 10x cheaper than Opus 4.8 - 2x faster and comparable performance

Try prompts like - fix all known bugs in my repo, code review the last 10 PRs etc.

@bindureddy The way agents are being layered together is fascinating

Using strong models for reasoning and lighter ones for tasks could really change how we build AI workflows bug fixing and PR reviews are just the start can't wait to see more applications emerge

@bindureddy The interesting part isn't "cheap planners + small workers." It's that orchestration costs are starting to dwarf inference costs at scale. Routing is the new bottleneck.

@bindureddy the routing is the easy win. the part i would watch is evals across the loop, because one cheap worker making a small wrong call can waste the whole swarm.

@bindureddy The shift from AI as a novelty to AI as default tooling is becoming really visible

This feels less like a tech demo and more like a workflow update. People are now building around AI to handle the grunt work they never enjoyed in the first place

This multi-tier routing architecture is exactly where production-ready agentic systems are heading. Using heavy models like Opus for orchestration/planning and lighter flash models for execution is the only scalable way to manage compute costs. The real magic in this setup is how you handle the state handoff. If the lighter models drift mid-task, how is the state machine passing the error context back to the planning layer without re-running the entire initialization loop? Brilliant breakthrough on cost optimization

@bindureddy it's a smart architecture. using the big models for planning and flash models for execution is the exact right move for scaling cost effectively.

@bindureddy Qwen3.5-9B writes edits as good as Opus 4.6. the gain is on the solver side, not the evolver.

@bindureddy what decides which subtasks are safe for the small models? the routing call seems like the actual hard problem, when it's wrong nothing errors, you just get quietly worse output

@bindureddy Nice approach. Been running a similar pattern locally - Qwen 3.6 as planner with smaller Deepseek quants doing the tool calls. The key insight is that cheaper models handle execution well if schemas are tight enough. What token budget did you set for the planner vs workers?

@bindureddy Impressive open‑source swarm! Curious how the cost drop scales with more complex loops.

@Chestu_eth Yup

@bindureddy 10x only holds if the planner emits clean subtasks. give the cheap executor an ambiguous one and it won't error, it'll just produce wrong output confidently. retries claw the savings back, so the planner prompt is where the real work is.

@bindureddy Building AI agents like coffee nowadays?

@bindureddy sounds promising, but curious how you manage coordination costs with all those agents.

@bindureddy Would love to see real world use cases and benchmarks using these systems. Personally I’m still not comfortable with delegating tasks to non-frontier models

@bindureddy The cost optimization angle is what makes this practical—routing planning to frontier models and execution to lightweight ones mirrors how infra teams tier compute. Curious how latency stacks with the Deepseek ↔ Gemma handoff at scale.

@bindureddy Multi-agent swarms do not only optimize cost.

They distribute agency across planners, workers, repos, tools, and commits.

That makes the control question bigger, not smaller:

Who can stop the swarm before “fix all bugs” becomes “ship unknown consequences”? 🛠️

@bindureddy Grok 4.20 over both for value imo

@bindureddy 10x cheaper? Big if true under real load. Planner/worker split is the right call, but I keep getting burned by handoff overhead. What's the catch?