Manaflow

What do they actually do

Manaflow builds cmux, an open‑source desktop and web tool that lets engineers run multiple AI coding agents in parallel against the same codebase, each in its own isolated workspace. It gives a per‑agent VS Code view of what the agent sees and executes, plus side‑by‑side diffs, test/command output, and live preview panes so you can verify results before opening or merging a PR from the same surface (cmux.dev, GitHub repo).

cmux runs locally via Docker or in cloud sandboxes, with macOS supported today, Linux in beta, and Windows on a waitlist. Users bring their own model/provider API keys. The project ships public releases and a web demo, and its repo shows active development and community interest (cmux.dev, GitHub repo).

Near term, the team is focused on sturdier verification/review tooling, broader agent/provider integrations, and wider OS support. Longer term, Manaflow’s aim is to make interfaces for managing fleets of agents—starting with coding agents—and to extend those verification-first patterns into non‑developer workflows where auditability and isolation matter (cmux.dev, YC profile, manaflow.com).

Who are their target customer(s)

• Individual software engineers using AI agents for code edits: They juggle multiple agent CLIs and terminals and rely on ad‑hoc diffs. They want one place to watch each agent run, see exactly what changed, run tests, and choose what to merge (cmux.dev).
• Engineering leads and code reviewers: They receive AI‑generated patches/PRs and need reproducible, per‑agent workspaces with clear diffs and preview environments to audit and approve changes confidently (cmux.dev, YC profile).
• SREs and DevOps engineers: They must limit risk from untrusted agent code and need sandboxing, isolation, and controlled cloud runs to protect production and developer machines (cmux.dev).
• AI/platform engineers stitching multiple model providers: They face fragmented agent CLIs and auth flows, and lack a repeatable way to run and compare multiple agents against the same repo, with traceable outputs (cmux.dev, GitHub repo).
• Non‑engineering operations/business users running automations: They want agent‑driven workflows (spreadsheets, email, file processing) but need a verification layer to trust outputs before actions affect customers or data (YC profile, manaflow.com).

How would they acquire their first 10, 50, and 100 customers

• First 10: Directly recruit early adopters from GitHub stars/issues, release downloaders, and web demo users for short free pilots. Run cmux on their repos in a 1‑hour onboarding to land one verified PR and capture feedback (cmux.dev, GitHub repo).
• First 50: Publish concise how‑to guides and recorded runs, post to developer communities (GitHub, HN, relevant subreddits), and host regular office hours to convert trials to pilots. Partner with maintainers of popular agent CLIs and ship ready‑made templates to reduce setup friction (cmux.dev, GitHub repo).
• First 100: Sell short paid team pilots to eng leads/SREs that include cloud sandboxes, SSO/permissions, and a support SLA so teams can safely run untrusted agents. Use pilot case studies (audit logs, test pass rates, time saved) plus YC introductions and targeted outreach to platform/AI eng orgs to close (cmux.dev, YC profile).

What is the rough total addressable market

Top-down context:

Professional developer counts range from ~19.6M (JetBrains 2024) to ~27M (Evans Data 2024), indicating a large user base for AI‑assisted tooling (JetBrains, Evans Data). AI coding assistants are tracked as a multi‑billion category by some analysts, e.g., Future Market Insights estimates ~$3.9B in 2025, while broader DevOps tooling is estimated around the low‑teens of billions in 2024 with strong growth (FMI, IMARC).

Bottom-up calculation:

Start with 19.6M professional developers (JetBrains). If 50–75% use or are open to AI coding tools (e.g., SlashData reports 59% using AI tools), that’s ~9.8M–14.7M in scope. If 5–20% of those have needs for multi‑agent runs, sandboxing, and verification, that yields ~0.5M–2.9M likely users for cmux‑style tooling (JetBrains, SlashData).

Assumptions:

• Base population uses JetBrains’ 19.6M professional developers; Evans Data’s 27M suggests an upper bound.
• AI assistant openness among professionals is 50–75%, anchored by SlashData’s 59% usage as a conservative reference point.
• 5–20% of AI‑using developers need multi‑agent, sandboxed, verification‑first workflows (engineers, reviewers, SRE/platform).

Who are some of their notable competitors

• GitHub Copilot (Agents): Copilot now includes agent capabilities that can write code, create PRs, and respond to feedback, reducing the need for separate orchestration for some workflows (GitHub Copilot).
• Cursor: An AI‑native IDE (a fork of VS Code) used for coding with LLMs. Overlaps on code generation/edits inside the editor, which may substitute for an external agent manager for some developers (Cursor, Wikipedia).
• OpenHands (formerly OpenDevin): An open platform for cloud coding agents that automate outer‑loop tasks like generating PRs, fixing tests, and summarizing changes—an alternative to managing multiple agents yourself (OpenHands).
• Aider: An open‑source CLI that edits codebases with LLMs and produces diffs/commits, offering a lightweight alternative to run and verify AI‑driven edits locally (Aider).
• GitHub Codespaces: Cloud, containerized dev environments often used for isolation and preview. While not an AI agent, it competes as the sandboxing layer teams use to safely run or review AI‑generated changes (Codespaces).