How a team of six AI specialists builds your app

Most AI app builders give you one chat box and one agent. That agent has to guess your market, decide what goes into the first version, design the data model and write the code, all in the same reply. When something goes wrong, you rarely know which of those decisions caused it.

OpenV2 works differently. In Team mode, six AI specialists share the work, each with one clear job, and they hand work to each other where you can see it. This article follows one app from the first message to a build you can install on your phone.

The six specialists

One rule matters more than the rest: only Leo changes your app. The others read, research and plan, and can write short notes in your project's docs folder. Their tools stop anything else, so a research step or a planning step can never overwrite your code.

An example: a habit tracker

Say you write one sentence:

A habit tracker with streaks and daily reminders.

Here is what happens next.

1. Ethan reads the request

Every message goes to Ethan unless you pick someone else. He sees that this is a new app, so the work goes through product scoping before anyone writes code. A small fix would go straight to Leo instead.

2. Clara researches, if you ask

If you want to know what already exists before you build, ask for research: "Research the habit-tracker market first." Clara works in three steps:

1. She writes a research plan: the objective, the key questions and the sources she proposes. She does not touch your app.
2. You approve the plan, or ask for changes.
3. She researches and delivers a brief with sources, findings, charts and diagrams.

The plan and the brief are saved as Markdown files in your project, so the rest of the team can use them. Clara separates evidence from inference and states the limits of what she found, which is what you want before you spend weeks on an idea.

3. Maya scopes the MVP

Maya turns the idea into a short first version, in plain words:

• a Today screen with the habits due today,
• a habit list to add and edit habits,
• a streak view,
• daily reminders,
• and a list of what waits for later, such as sharing with friends.

Scoping is the step a single agent usually skips. Without it, the first version tries to do everything and does most of it badly.

4. Oliver designs the hard parts

For anything technical that is easy to get wrong, Oliver decides how it works before Leo writes it: how habits and streaks are stored, how a streak is counted across time zones, how reminders are scheduled, and what happens when the user changes a habit's days. A streak bug found after launch costs far more than a decision made up front.

5. Leo builds it

Leo writes the app in Swift and SwiftUI for iPhone (or Kotlin for Android), creates the images and the app icon, runs the build check and fixes what breaks. You then test it in the cloud simulator in your browser, or install it on your own phone with Companion.

6. Sofia reads the numbers, later

Once people use the app, Sofia reads your data and metrics. She checks the numbers before she draws conclusions, for example which habits people drop first and on which day.

Every handoff is visible

Each specialist says what they are doing and then hands off. The handoff appears in the chat as a compact Brief for card. Open it to read exactly what the next specialist received. If a request is unclear in a way that changes what gets built, a specialist asks you one to three multiple-choice questions in a card instead of guessing. You can answer or skip.

You stay in control

• Talk to one specialist directly. Click a specialist on the dashboard, use the team picker next to the chat box, or write @Oliver, how should sync work?.
• Skip what you don't need. Small changes and fixes go straight to Leo.
• Switch to Solo whenever you want one engineer doing everything. Team brings the other five back.

Why a team ships better apps

A single agent is fast at writing code. The expensive mistakes in an app are rarely typos, though. They are a first version with too many features, a data model that cannot hold the next feature, or a market that already has ten free apps doing the same thing. Each of those has an owner in Team mode:

1. Research before code, with sources you can check.
2. A short MVP, so the first version ships.
3. Architecture before the data model, so the next feature fits.
4. One engineer who touches the code, so changes stay consistent.
5. Someone who checks the numbers after launch.

What it costs

Messages that build something (code, images, the icon, backend setup) use your plan's usage. Plain conversation, such as questions and advice, does not count, in either mode. Research uses usage like other work that creates files. See pricing and plans and usage.

Try it

Describe the app you want in one sentence and let the team take it from there. Read more about the AI team, or see how this compares with Rork and Lovable.

Frequently asked questions

What is Team mode in OpenV2?

Team mode puts six AI specialists on your app: Ethan (Team Leader), Clara (Deep Researcher), Maya (Product Manager), Oliver (Architect), Leo (Engineer) and Sofia (Data Analyst). They hand work to each other and you can see every handoff.

Who changes my code in Team mode?

Only Leo, the engineer. The other specialists read, research and plan, and can only write notes in the project's docs folder.

Do I have to use all six specialists?

No. A new app goes through Ethan, Maya and Leo by default. Clara, Oliver and Sofia step in when you ask for research, when a technical design is hard, or when you have data to read. Small fixes go straight to Leo.

Does Team mode use more of my plan?

Messages that build something use your plan's usage in both modes, and plain conversation never counts. A bigger task uses more than a small edit.