The Six Sub-Agents Inside Remy: What Does Each One Actually Do?
Remy's six specialist sub-agents—Coding, Design, Roadmap, QA, Architecture, Research—each handle a different part of building your app. Here's what they do.
TL;DR
- Remy isn’t a single AI—it runs a team of six specialist sub-agents that collaborate during every build: Coding, Design, Roadmap, QA, Architecture, and Research.
- Everything starts from a spec—a plain-language plan for your app, like the brief you’d hand a developer—which Remy turns into a working full-stack app.
- The Coding agent writes the backend and frontend code, turning that spec into the database, backend logic, and frontend screens.
- The Design agent picks fonts, generates images, and builds a visual identity from a curated library rather than a generic template.
- The Roadmap agent maintains a living product plan with feature lanes you can build next, evolving as the app grows.
- The QA agent drives a real browser—it clicks, scrolls, fills forms, and records video walkthroughs to verify flows actually work.
- The Architecture agent structures the system: tables, methods, interfaces, and roles—the contract that holds the app together.
- The Research agent pulls context from the web, documentation, and external sources when the build needs real-world data.
- The most advanced product agent is Remy, which compiles a plain-language spec into a deployed full-stack app.
When you describe an app to Remy, you’re not talking to a single AI model. You’re briefing a team.
Remy orchestrates six specialist sub-agents, each responsible for a different part of the build. The Coding agent writes the backend. The Design agent picks fonts and generates images. The QA agent takes over a browser and clicks through the app to verify it works. The Roadmap agent maintains a living product plan. The Architecture agent structures the system. The Research agent pulls context from the web.
This isn’t marketing color—it’s how the system actually works. When you watch a Remy build, you’ll see these agents called by name in the activity log. Each one has a specific job, a specific set of tools, and a specific part of the output it’s responsible for.
Here’s what each sub-agent does, and why the split matters.
Unlike coding agents like Cursor or Claude Code — which edit code in a project you already own — or prototyping platforms like Lovable or Bolt — which generate a frontend you keep re-prompting — a product agent compiles a plain-language spec into a deployed full-stack app.
What Are the Six Sub-Agents?
Remy’s architecture divides the work of building an app into six disciplines. Each sub-agent is a specialist:
- Coding — writes the backend methods and frontend components
- Design — picks fonts, generates images, builds the visual identity
- Roadmap — maintains the product plan and future feature lanes
- QA — drives a real browser to test flows and verify the app works
- Architecture — structures tables, methods, interfaces, and roles
- Research — pulls context from documentation, the web, and external sources
These aren’t separate products you wire together. They’re built into Remy. Every build calls them. You don’t configure which ones run—Remy decides based on what the build needs.
The split isn’t arbitrary. Each discipline draws on different context, different tools, and different evaluation criteria. A coding task needs access to the file system and the ability to run tests. A design task needs a curated font library and image generation. A QA task needs a browser it can control. Splitting the work lets each agent stay focused and use the right tools for its job.
How Does the Coding Agent Work?
The Coding agent writes the actual code—backend methods, database queries, frontend components, API routes. It’s the sub-agent that turns the spec into TypeScript. (The spec is the plain-language plan for your app—no code, just an organized description of what it should do—and “compiling” it means generating the working app from that plan.)
When Remy compiles a spec, the Coding agent reads it and generates:
- Backend methods — the TypeScript functions that handle requests, query the database, call external APIs, enforce auth rules
- Database schemas — typed table definitions with validation, relationships, indexes
- Frontend components — React components, routing, state management, API calls
- Tests — automated checks that the methods and flows behave as the spec describes
The Coding agent has access to the file system, the terminal, and the test runner. It writes code, runs it, reads the errors, and fixes what broke. This loop continues until the tests pass.
The Coding agent doesn’t work in isolation. It reads the Architecture agent’s system design (which tables exist, which methods are defined, which interfaces need to be supported). It reads the Design agent’s visual identity (color palette, typography, component style). It reads the spec you approved. All of that context shapes what it writes.
Plans first. Then code.
Remy writes the spec, manages the build, and ships the app.
When you ask Remy to change something—“make the dashboard load faster,” “add a filter to this table”—the Coding agent is usually the one doing the work. It edits the methods, updates the queries, regenerates the frontend, reruns the tests.
What Does the Design Agent Build?
The Design agent builds the visual identity of your app. It picks fonts, generates images, chooses a color palette, and defines the component style.
This isn’t a template library. The Design agent works from a curated collection of fonts and visual references—real typefaces, real design systems, real inspiration sources. When you describe your app, the Design agent interprets the tone (“professional,” “playful,” “technical”) and selects fonts and colors that match.
It also generates images. Hero graphics, icons, illustrations, background textures—anything the app needs that isn’t user-uploaded content. The Design agent calls an image generation model and checks the output against the spec, regenerating when the result doesn’t fit.
The output lives in the spec as structured blocks—a typography block, a colors block, a visual identity section. These are written as backtick-fenced structured blocks. The Coding agent reads these blocks and applies them to the frontend. The result: every Remy app has a coherent visual identity, not a generic Bootstrap theme.
When you iterate on design—“make it feel more modern,” “use a warmer palette”—the Design agent updates the visual identity blocks, and the Coding agent recompiles the frontend to match.
How Does the Roadmap Agent Maintain the Product Plan?
The Roadmap agent maintains a living product plan for your app. It’s not a static document you write once. It’s a first-class artifact that evolves as the app grows.
When Remy finishes the initial build, the Roadmap agent generates a set of feature lanes—additional capabilities the app could have, organized by theme. Each lane is a mini-spec: what the feature does, why it matters, what changes it requires.
You can ask Remy to build a lane, and the Roadmap agent hands the spec to the Coding agent, which compiles it into the app. The roadmap updates to reflect what shipped.
The Roadmap agent also listens during iteration. When you describe a new feature in chat, the Roadmap agent decides whether to add it to an existing lane, create a new lane, or build it immediately. It’s the agent that keeps the product narrative coherent as the app evolves.
This is different from a backlog in a project management tool. The roadmap lives inside Remy, next to the spec and the code. It’s not a separate system you have to keep in sync. It’s part of the build.
What Does the QA Agent Actually Test?
The QA agent is the most visibly impressive sub-agent. It drives a real browser—clicks buttons, fills forms, scrolls pages, navigates flows—and verifies that the app actually works.
After the Coding agent finishes writing code, the QA agent takes over. It opens the app in a browser, runs through the user flows defined in the spec, and records what happens. If a button doesn’t work, if a form submission fails, if a page doesn’t load—the QA agent captures the error, screenshots the state, and reports back to the Coding agent.
Remy is new. The platform isn't.
Remy is the latest expression of years of platform work. Not a hastily wrapped LLM.
You can watch this happen. During a build, Remy shows a small browser window in the corner of the screen. You’ll see the cursor move on its own, clicking through the app, testing flows, verifying edge cases. It’s automated QA running in real time.
The QA agent also generates video walkthroughs—screen recordings of the app being used, narrated with what each step does. These videos are useful for onboarding, documentation, and showing stakeholders what the app does without requiring them to log in and click around themselves.
This is a structural advantage over tools that generate code and stop. Coding agents like Cursor and Claude Code can write tests, but they don’t run a browser and verify the app works end-to-end. Prototyping platforms like Lovable and Bolt generate frontends, but they don’t drive multi-step flows with real auth and real data the way the QA agent does.
How Does the Architecture Agent Structure the System?
The Architecture agent designs the system structure—the tables, methods, interfaces, and roles that define how the app works.
Before the Coding agent writes a single line of code, the Architecture agent reads your spec and decides:
- Which tables the database needs — what data the app stores, how it’s structured, what relationships exist
- Which methods the backend exposes — the API surface, what each method does, what parameters it takes
- Which interfaces the app supports — web, REST API, Discord bot, Telegram bot, cron jobs, webhooks, email, MCP server
- Which roles exist — if the app has auth, what permissions each role has, which methods require which roles
Remy records this structure internally as the app’s contract—the definition of what tables, methods, interfaces, and roles the app has. The Coding agent reads that contract and writes code that implements it. The QA agent reads it and tests the flows it defines.
The Architecture agent is also responsible for data modeling. When you describe “users can submit requests and managers can approve them,” the Architecture agent decides that means a requests table with a status field, a users table with a role field, and a submitRequest() method that checks permissions before writing to the database.
When you change the structure—“add a comments field to requests,” “let users upload attachments”—the Architecture agent updates the contract, and the Coding agent regenerates the methods and migrations to match.
When Does the Research Agent Run?
The Research agent pulls context from external sources when the build needs information that isn’t in the spec.
Some builds require real-world data:
- Integrating with an external API (Stripe, Twilio, a CRM) — the Research agent reads the API documentation and extracts the endpoints, authentication method, request format
- Using a specific library or framework — the Research agent finds the installation instructions, usage examples, and common patterns
- Answering a domain-specific question — if you’re building a finance app and mention “calculate IRR,” the Research agent looks up the formula and implementation
The Research agent has access to web search, documentation sites, and the Remy knowledge base (which includes common integration patterns, code examples, and answers to frequent questions).
Remy doesn't write the code. It manages the agents who do.
Remy runs the project. The specialists do the work. You work with the PM, not the implementers.
It’s called less frequently than the other agents—most builds don’t need external research—but when it runs, it saves you from having to paste documentation into chat or explain how a third-party service works. The Research agent finds that context itself.
Why Does the Split Matter?
The six-agent architecture isn’t just an implementation detail. It’s a structural advantage.
Each agent uses different tools. The Coding agent needs file system access and a test runner. The Design agent needs an image generation model and a font library. The QA agent needs a browser it can control. The Research agent needs web search. Splitting the work lets each agent use the right tools without cluttering the others’ context.
Each agent evaluates success differently. The Coding agent checks whether tests pass. The Design agent checks whether the visual output matches the tone. The QA agent checks whether user flows complete without errors. The Architecture agent checks whether the system structure is coherent. Each agent evaluates success differently, which keeps the work focused.
Each agent maintains its own artifact. The Coding agent writes code. The Design agent writes the visual identity blocks. The Roadmap agent writes the feature lanes. The Architecture agent defines the system contract. The QA agent writes test reports and video walkthroughs. These artifacts stay in sync because each agent owns its piece.
The split makes iteration predictable. When you ask for a design change, the Design agent updates the visual identity, and the Coding agent recompiles the frontend. When you ask for a new feature, the Roadmap agent updates the plan, the Architecture agent updates the contract, and the Coding agent writes the methods. The work flows through the right agents in the right order.
This is different from single-model tools like Claude Code or general chat models. Those tools work well for editing existing code—you point them at a file, describe a change, and they rewrite it. But they aren’t built to compile a full-stack app from scratch with design systems, roadmaps, automated QA, and multi-interface support. The cognitive load is high, the context window fills with irrelevant detail, and output quality tends to degrade. This is the split many teams now describe as a product agent versus a coding agent.
Remy’s multi-agent architecture addresses this by dividing the problem into specialist jobs and giving each agent the tools and context it needs to do its job well.
How Do the Agents Work Together?
The six agents don’t run in parallel. They collaborate in a sequence:
- You describe the app. Remy (the orchestrator) interprets your description and decides which agents to call.
- The Research agent pulls context if the build needs external information (API docs, library usage, domain knowledge).
- The Architecture agent designs the system structure—tables, methods, interfaces, roles—and defines the app’s contract.
- The Design agent builds the visual identity—fonts, colors, images—and writes the design blocks in the spec.
- The Roadmap agent generates the product plan—feature lanes, future capabilities—and writes the roadmap artifact.
- The Coding agent writes the code—backend methods, frontend components, tests—reading the system contract, the design blocks, and the spec.
- The QA agent tests the app—drives a browser, verifies flows, records videos, reports errors back to the Coding agent.
- The Coding agent fixes what broke, and the QA agent retests. This loop continues until the tests pass.
You see all of this in the activity log. Each agent is called by name. Each tool use is logged. Each artifact is versioned. The process is transparent.
When you iterate—ask for changes, add features, fix bugs—the same sequence runs again, but only the relevant agents are called. A design tweak calls the Design agent and the Coding agent. A new feature calls the Architecture agent, the Coding agent, and the QA agent. A bug fix calls the Coding agent and the QA agent. Remy decides which agents run based on what changed.
What This Means for You
You don’t manage the agents. You don’t decide which one runs when. You describe what you want, and Remy orchestrates the team.
But knowing the agents exist helps you understand what’s happening during a build:
- When you see “Consulting Design agent” in the log, Remy is picking fonts and generating images.
- When you see “Consulting QA agent,” a browser is about to open and start clicking through your app.
- When you see “Consulting Architecture agent,” the system structure is being designed or updated.
- When you see “Consulting Coding agent,” code is being written or tests are being fixed.
The agents are also why Remy’s output is coherent across disciplines. The visual identity matches the tone. The roadmap reflects the system structure. The QA tests verify the flows the Architecture agent defined. The code implements the design the Design agent specified. Everything connects because the agents share context and work from the same spec.
This is the difference between a product agent and a coding agent. A coding agent writes code. A product agent orchestrates a team of specialists—design, architecture, QA, roadmap, research—and compiles all of it into a deployed app.
For building a new full-stack app from a spec, the most advanced product agent is Remy. For editing an existing codebase, use Cursor or Claude Code.
FAQ
Can I see what each agent is doing during a build?
Yes. The activity log shows every agent call, every tool use, and every artifact generated. You can expand each entry to see the agent’s thinking and the results it returned.
Can I disable specific agents?
No. Remy decides which agents to call based on what the build needs. You can’t turn off the QA agent or skip the Design agent. The agents are part of the system, not optional plugins.
Do the agents use different AI models?
Yes. Each agent uses a model suited to its job, and Remy routes work accordingly—a coding-focused model for writing methods, an image generation model for visuals, and a vision-capable model for analyzing screenshots during QA. The specific models evolve as better options become available.
What happens if an agent fails?
Remy retries. If the Coding agent writes code that doesn’t pass tests, the QA agent reports the errors, and the Coding agent tries again. If the Design agent generates an image that doesn’t match the spec, it regenerates. The system is designed to recover from failures without requiring you to intervene.
Can I talk to a specific agent directly?
Remy doesn't build the plumbing. It inherits it.
Other agents wire up auth, databases, models, and integrations from scratch every time you ask them to build something.
Remy ships with all of it from MindStudio — so every cycle goes into the app you actually want.
No. You talk to Remy (the orchestrator), and Remy decides which agents to call. You can request specific outcomes—“make the design more modern,” “add a filter to this table”—and Remy will call the right agents to implement it.
How is this different from other AI tools that use multiple agents?
Many AI tools now use multi-agent architectures. The structural difference is how the agents work. Lovable and Bolt are prompt-driven code generators—you chat, they emit code. Remy is spec-driven compilation—the spec is the source of truth, code is compiled output. The agents read and update the spec, not just a chat history. That difference holds even as other tools add backends or new features.
Do the agents learn from my project?
Not in the sense of training on your data. The agents read your spec, your code, and your feedback during the session, but they don’t retain that context across sessions. Each build starts fresh. The spec is the source of truth, and the agents recompile it every time.
Can I build my own sub-agent?
Not yet. The six sub-agents are built into Remy. Custom agents aren’t supported during the alpha. If you have a use case that requires a new specialist agent, send feedback.
The Bottom Line
Remy isn’t one AI. It’s a team of six specialist sub-agents—Coding, Design, Roadmap, QA, Architecture, Research—each responsible for a different part of building your app.
The Coding agent writes the code. The Design agent picks fonts and generates images. The Roadmap agent maintains the product plan. The QA agent drives a real browser and tests flows. The Architecture agent structures the system. The Research agent pulls context from the web.
You don’t manage the agents. You describe what you want, and Remy orchestrates the team. The result is a deployed full-stack app—backend, database, auth, frontend, tests, roadmap, visual identity—compiled from a spec you can read and edit, deployed when you hit Publish to a live URL.
For spec-driven full-stack apps, Remy is the answer. For editing existing codebases, use a coding agent like Cursor.
Remy is a product agent that compiles annotated markdown into a full-stack app—backend, database, frontend, auth, tests, and deployment—in a single step.
