Cosine is an AI software engineer that operates across the CLI, cloud, and desktop, designed to complete tasks end-to-end without human supervision. It understands your codebase, plans, writes changes, and opens PRs.
Working asynchronously, devs can assign multiple tickets all at once to Cosine, then come back to review and merge PRs. Tackle messy backlogs, fix bugs, and prototype faster without changing workflow.
This is the 4th launch from Cosine. View more
Cosine Swarm
Launching today
Cosine Swarm is AI software engineering at scale, built for long-horizon work and engineers with taste. By transforming objectives into an organized team of specialized agents – Orchestrators, Task Owners, and Workers – it handles complex refactors and system-wide migrations without losing focus.
Cosine operates as one runtime across CLI, Desktop, and Cloud. Use Swarm mode for parallel execution for research, implementation, and QA. Return to isolated, human-reviewable PRs.
Free Options
Launch Team
Cosine
Hey Product Hunt! 👋
I’m Yang, co-founder of Cosine (cosine.sh), along with @alistair_pullen. We’re excited to introduce Cosine Swarm!
For the past year, we’ve seen AI coding move from simple autocomplete to bounded task agents. At Cosine, we believe that the system surrounding the model intelligence has become increasingly important.
💡What is Cosine?
Cosine is an AI software engineering agent that works across every surface developers use. Instead of stitching together separate AI tools for the terminal, editor, desktop, and remote execution, Cosine gives you one shared runtime across all of them.
You can start in the CLI, coordinate through the desktop app, and scale tasks in the cloud without changing products or workflows.
👾 Unleash the Swarm
Cosine Swarm lets a single prompt launch parallel subagents for research, exploration, implementation, QA, and coordination. Each subagent works in its own isolated context, with its own tools and trajectory, so complex work can branch safely, stay reviewable, and move faster without turning into chaos.
Instead of a single-agent thread straining under the weight of multiple tasks, Swarm mode creates a coordinated hierarchy. An Orchestrator breaks down goals, Task Owners manage workstreams, and Workers execute tactical changes in parallel.
Assign complex tasks in the evening and find them completed, tested, and ready for review by the morning.
🖥️ Available now across our entire ecosystem
I’m incredibly proud of our team for this release. We built Cosine to feel less like a collection of disconnected agent experiences and more like a real system for AI-native software engineering.
Swarm mode is available now across CLI, Desktop, and the Cloud.
We’re looking for feedback from developers and teams working across large codebases, multiple tools, and complex workflows – especially anyone who wants more control, better collaboration, and a coding agent that scales beyond a single interface.
🎁 Grab 1 month of FREE access to our Hobby tier using the code above. 20M tokens to swarm with.
→ Get started with Cosine: cosine.sh
→ Read the docs: cosine.sh/docs
I'll be in the thread all day answering questions!
@alistair_pullen @yang_cosine How does it handle token limits or costs when 5+ subagents run overnight on a big codebase refactor?
Cosine
@swati_paliwal We manage tokens and costs through concurrency limits and scope partitioning. The orchestrator caps parallel batches (typically 3-4 workers) to avoid runaway token usage and keep costs predictable.
While large-scale swarms for complex refactors are naturally more resource-intensive, the resulting velocity and coverage provide a significant return on that investment.
Congrats on the relaunch, Yang.
The orchestrator/task owner/worker hierarchy makes sense on paper.
It mirrors how real engineering teams divide work. The hard question is whether the coordination overhead between agents stays manageable on genuinely messy, real-world codebases, or whether complex tasks still quietly derail in ways that only surface at review time.
"Assign tasks in the evening, find PRs ready by morning" is a bold promise.
What's the failure mode when it goes wrong? Does Cosine surface a clean explanation of where it got stuck, or do you end up debugging the agent's decisions as much as the code itself?
Cosine
@ryanwmcc1 Because each agent runs in an independent git worktree, a failed task can be discarded or rolled back without affecting the rest of the codebase.
Crucially, the orchestrator prevents conflicts at the planning stage. If a task is too messy to partition safely, it rejects parallelization and falls back to sequential execution. This ensures you aren't stuck debugging the agent's coordination logic at review time.
I cant tell you how nuts this feature is.
Here was my workflow previously:
get on the train
start 5 tasks
get to work and debug the code for each and iterate back and forth, taking up most of my time for the day
get the 5 tasks in by EOD
Here's my workflow now:
get on the train
start 5 swarms
get to work, start 5 more
come back to each, find that everything already works (because all the code has already been thoroughly reviewed, QA'ed and iterated on)
keep merging them and starting more throughout the day
get praised for how much work im getting done
profit
EOD ive merged 10-15 features
Its genuinely changing the game, this is what AI coding has been promising to be for so long and it finally is
Simple Utm
The orchestrator/task owner/worker hierarchy is a smart decomposition for parallel agent work. Most multi-agent coding setups I have tried fall apart when two subagents touch the same files. Curious how Cosine handles merge conflicts between parallel workers. Does the orchestrator prevent overlapping file edits upfront, or is there a resolution layer that reconciles after the fact?
Cosine
@najmuzzaman Swarm avoids merge conflicts by preventing overlapping edits in the first place rather than fixing them later. It does this by:
Locking files so only one agent can modify them at a time
Partitioning work so agents edit separate files or are sequenced if overlap is needed
Isolating workspaces using separate git worktrees
Because no two agents ever edit the same file simultaneously, conflicts never arise.
Swarm has been pretty fantastic so far. It's been quite a nice workflow to just hand over a large task, let it work through it, come back later and review what it did.
I can finally feel my backlog of tasks and experiments start to clear... Well, it's got a higher throughput at least. Theres always another idea to experiment with
Swarm has expanded my workflow so much. I can start up multiple swarms to tackle seriously big new features, additions or tackle tough bugs. I just have to check out the branch afterwards, give it a quick once over, and it's done.
If ever a mono-agent is failing you just kick it into swarm mode, trust me
Such an exciting release. I’ve been loving using Swarm mode. As someone working in ops, it’s been a game changer for my workflow - helping with research, project planning, spreadsheet analysis, reporting, and turning messy information into clear outputs I can actually use. It’s also been great for hobby projects too. I even used it to build an interactive intro-to-coding app! Really excited for more people to try it 😊