What Is Marblo — the AI Agent Army Workspace

One-line definition

Marblo is a desktop app that orchestrates multiple AI coding agents simultaneously on a single kanban board. A central orchestrator splits a large job into small tasks, assigns them to individual agents, and tracks in real time who is doing what. It runs on macOS and Windows.

Where Cursor or Copilot put a single agent at your side, Marblo runs an army of agents. One developer sits in the orchestrator's seat and directs several agents — each possibly running a different model — all at once.

Why an army, not a single agent

Most AI coding tools today are one-to-one and conversational: a single developer chats with a single agent to change files. It's intuitive, but while the agent grinds through a long task, the developer effectively waits. Kick off a backend refactor, and your frontend work sits idle until it returns.

Real software work is parallel. Teams move fast precisely because the person touching the API, the person building the screen, and the person filling in tests all move at once. Marblo brings that parallelism onto a single workstation. The developer's role shifts from typing every line to being the orchestrator — handing work out to several agents and reviewing what comes back.

Core components

Marblo is made of five parts. Here they are, one at a time.

1. Heterogeneous agents

Marblo isn't tied to one model. It runs Claude, GPT/Codex, and Antigravity at once. Because each model is good at different things, you can assign roles — backend, frontend, testing — to fit each model's strengths. When one agent gets stuck, you can throw the same problem at a different model. Not being locked to a single vendor is both a matter of freedom and a hedge in an era when the model landscape shifts fast.

2. Central orchestrator

The orchestrator is Marblo's conductor. It breaks a large goal into several tasks, assigns each task to the right agent, and manages the dependencies and ordering between them. Because the orchestrator keeps track of relationships like "B can't start until A is done," the developer doesn't have to coordinate every hand-off by hand.

3. Kanban board

Every task moves across the kanban board along the flow TODO → IN_PROGRESS → REVIEW → DONE. On a single screen you see which agent is doing what, what's waiting for review, and what's finished. Even with many agents moving at once, state doesn't scatter — it converges onto one board.

4. MCP native

Marblo supports the Model Context Protocol (MCP) out of the box. MCP is the standard conduit through which an agent reaches tools like the file system, databases, and external APIs. Because multiple agents share the same set of tools, they collaborate on a consistent context instead of each wiring itself into the environment its own way.

5. Local execution

Every agent runs on your machine. Your code is not uploaded to Marblo's servers. Keeping the source local matters for security and compliance, and it's especially meaningful in environments — like an internal codebase — where sending code outside is sensitive.

Cost model — bring your own model

To understand Marblo's pricing, separate two costs.

The first is AI usage. Each agent runs on your own API key or subscription: Claude bills to your Anthropic account, GPT/Codex to your OpenAI account, and so on. That cost is settled directly between you and the model provider — it never passes through Marblo.

The second is the orchestration cost — the Marblo subscription itself. This is the price of the layer that splits, assigns, tracks, and safely merges the work of many agents, and it does not include AI usage fees. The plans:

• Free — ₩0/month. Enough to try Marblo and learn the orchestration flow.
• Pro — ₩19,000/month. For developers ready to run an agent army in earnest.

Because of this split, you're free to pick whatever models you want, control your AI spend directly with each provider, and pay Marblo only for the conducting layer.

A day with Marblo

In practice it flows roughly like this. In the morning you hand the orchestrator a goal — say, "add a coupon feature to the payments module." The orchestrator breaks it into a backend API task, a frontend form task, and a set of test cases. Each lands on the board as TODO, and the agent whose strengths fit picks it up and moves it to IN_PROGRESS.

When an agent finishes its code, the task moves to REVIEW. This is where the human steps in. You inspect the change and, if it's good, move it to DONE; if it falls short, you send it back with a comment. Many agents move at once, but because the checkpoint converges on the single REVIEW column, you never lose control. That's what Marblo means by "push many things in parallel while staying in control."

Who it's for

• Developers who want team-scale output on their own — running frontend, backend, and tests at once to lift the throughput of a solo build.
• People who want to push work in parallel while staying in control — letting agents loose without losing sight, on the board, of what's happening.
• People who don't want to be locked to one AI vendor — free to mix models and swap them as the situation calls for.
• Environments where code can't leave for outside servers — where local execution and BYO models line up with compliance and security needs.

Getting started

Grab the macOS/Windows app from the download page and start right away. Learn the orchestration flow on the Free plan (₩0/month) first, then move to Pro (₩19,000/month) when you need it. All you need to bring is the API key or subscription for the models you want to run.