See how a single /goal prompt with Claude Fable 5 produced a business plan, brand, product, landing page, and launch videos in under 4 hours.
One Prompt, One Company, Four Hours #
The premise sounds absurd: type a single prompt and walk away while an AI agent builds you a company. Not a pitch deck. Not a logo. An actual company — with a business plan, brand identity, product spec, landing page copy, and launch videos.
That’s what a multi-agent workflow running Claude can do today. And if you haven’t seen it in action, the output is genuinely surprising — not because it’s perfect, but because it’s complete.
This article walks through exactly how it works: the prompt structure, the agent chain, what gets produced at each step, and where things still need a human in the loop. Whether you’re a founder, a builder, or just someone who likes understanding what’s actually possible with Claude and multi-agent workflows right now, this is worth reading.
The Experiment: What “One Prompt” Actually Means #
Let’s be specific. The single prompt isn’t “build me a company.” That produces garbage.
The prompt that makes this work is a structured /goal
command — a single input that contains enough context for the first agent to decompose the task into sub-goals and hand them off downstream.
Here’s an example of what that looks like:
/goal: Launch a B2C subscription service that helps freelancers track their taxes
and estimate quarterly payments automatically. Target: US-based freelancers earning
$30K–$150K/year. Tone: friendly, no-nonsense, slightly irreverent.
Deadline: build everything needed to put up a landing page and make the first post.
That’s it. One block of text. The multi-agent system takes it from there.
What happens next is that Claude — acting as the orchestrator agent — reads the goal, identifies the parallel workstreams needed (brand, product, copy, media), and spawns or delegates to specialized sub-agents for each.
The key word is parallel. This isn’t a linear chatbot session where you wait for one thing before asking for the next. The agents work concurrently, passing structured outputs to each other as dependencies get resolved.
Step One: The Business Plan Agent #
The first agent to run is the strategy layer. It takes your /goal
input and produces a structured business plan — not a 40-page document, but a lean one-pager that every downstream agent can reference as the source of truth.
What it typically includes:
Problem statement— Articulated in customer language, not founder language** Target customer profile**— Demographics, pain points, existing alternatives they use** Value proposition**— One sentence, two max** Revenue model**— How money comes in, what the pricing tiers look like** Key risks**— The top 3 things that could make this fail** Success metrics**— How you’ll know in 90 days if this is working
Claude is particularly good at this step because it can infer what’s missing from your prompt and either flag it or make a reasonable assumption with a note attached. In the freelancer tax example, the agent might note: “Assumed US-only for MVP scope — international tax compliance adds significant complexity.”
That assumption gets embedded in the business plan document and passed downstream. Every other agent now works within those constraints.
Step Two: Brand Identity Without a Designer #
The brand agent receives the business plan and generates the brand stack. This is where Claude’s ability to hold a lot of context simultaneously really matters — it’s not just generating a name, it’s generating a coherent system.
The output from a well-configured brand agent typically includes:
3–5 name options with rationale for each (not just the names, but why they work given the target customer and tone)Tagline variants— usually 3 per name** Brand voice guidelines**— how the brand speaks, what it avoids, 3 example phrases in-voice and 3 out-of-voice** Visual direction**— color palette guidance, typography category (not specific fonts, but style: “clean geometric sans-serif, not playful rounded”), imagery mood
Notice what’s not on that list: an actual logo. That part still involves a separate media generation agent — or a human designer. The brand agent is producing the brief, not the final files. That’s an important distinction.
From the freelancer tax example, the agent might produce names like Quartly, Taxly, or Float — and for each, explain which audience segment it resonates with and what the risk is (e.g., “Float has strong brand equity in cash flow tools — possible confusion with existing products”).
A human reviews and picks one. That selection gets piped into everything else.
Step Three: Product Spec and Feature Prioritization #
Other agents start typing. Remy starts asking. #
Scoping, trade-offs, edge cases — the real work. Before a line of code.
Most “build a company” demonstrations skip this step. They jump from brand to landing page, which means the landing page describes features that don’t actually exist or makes promises the product can’t keep.
The product spec agent prevents that.
It takes the business plan and brand brief and generates a structured product specification:
Core feature set (MVP)
What gets built first. Usually 3–5 features that are both high-value and low-complexity. The agent is explicitly instructed to apply a Jobs-to-Be-Done framework — what job is the customer hiring this product to do, and what’s the minimum required to do that job well?
Phase 2 features
Things that matter but can wait. These are captured so they’re not forgotten, but also so they’re not over-promised at launch.
Integration dependencies
What tools or APIs the product needs to connect to. For a tax estimation tool: IRS quarterly deadline data, bank account read access (Plaid), possibly invoice tracking from Stripe or PayPal.
Technical architecture summary
A high-level description that a developer could actually use as a starting point. Not code — but enough specificity that you’re not starting from zero.
This step slows the workflow down slightly because the agent often asks clarifying questions or produces multiple versions to choose from. That’s by design. A vague product spec creates downstream problems that are much more expensive to fix.
Step Four: Landing Page Copy That Actually Converts #
The copy agent is where the workflow gets visually interesting. It receives the brand voice guidelines, the product spec, and the target customer profile — and produces a complete landing page content brief.
This isn’t “here’s some placeholder text.” It’s the actual copy, structured by section:
Hero headline and subheadline— Multiple variants, each with a different angle (fear-based vs. aspiration-based vs. social proof-based)** Feature blocks**— One for each core MVP feature, written in benefit language (“Know exactly what you owe before the IRS does” not “Real-time tax estimation engine”)Social proof section— Placeholder structure with suggested testimonial formats and what type of customer story would be most credible** Pricing section**— Draft copy for each tier, including the framing of the free vs. paid divide** FAQ copy**— 5–8 questions the target customer is most likely to have, answered in brand voice** CTA copy**— Headline, button text, and supporting microcopy for the primary conversion action
Claude’s strength here is in the coherence across sections. The hero headline, the feature descriptions, and the CTA all feel like they’re from the same brand, speaking to the same customer, about the same product. That sounds obvious, but it’s genuinely hard to do when copy is generated piecemeal.
Step Five: Launch Videos and Visual Assets #
This is where a media generation layer gets added to the agent chain.
The video brief agent takes the landing page copy and brand direction and produces scripts and production briefs for:
- A 60-second explainer video (for the website)
- A 15-second social ad (for paid acquisition)
- A 30-second founder story (for organic social)
Each brief includes: script, visual direction, pacing notes, CTA, and suggested voiceover tone.
Other agents ship a demo. Remy ships an app. #
Real backend. Real database. Real auth. Real plumbing. Remy has it all.
For teams using MindStudio’s AI Media Workbench, this is where the workflow gets especially fast. The media layer can take those scripts and generate:
- AI voiceovers in the selected tone
- B-roll imagery matched to each script beat
- Subtitle generation for the final clips
- Multiple aspect ratio exports (16:9 for web, 9:16 for vertical social)
All within the same workflow. No context-switching to a separate tool, no re-up assets, no reformatting.
The quality ceiling for AI-generated video is still lower than a professional production. But for a launch video that gets tested against zero existing audience? It’s more than good enough to validate whether the message lands before investing in production.
What the Multi-Agent Architecture Actually Looks Like #
The reason this works — and the reason a single chatbot session can’t replicate it — is the structure of the agent chain.
Here’s the dependency graph in plain terms:
/goal prompt
└── Business Plan Agent
├── Brand Agent (depends on: business plan)
│ └── Copy Agent (depends on: brand, product spec)
│ └── Video Brief Agent (depends on: copy)
└── Product Spec Agent (depends on: business plan)
└── Copy Agent (same instance, parallel input)
The orchestrator — in this case, Claude acting as the top-level agent — manages state across this graph. It knows which agents have finished, which are still running, and what the blocking dependencies are.
This is fundamentally different from a simple prompt chain where output A feeds input B feeds input C. In a multi-agent workflow, the copy agent is receiving inputs from two upstream agents simultaneously and merging them before producing its output. The orchestrator handles that merge.
Claude is well-suited to this role because it can hold large context windows, reason about dependencies, and produce structured outputs (like JSON or Markdown) that other agents can parse cleanly. The multi-agent loop — where agents can call other agents, check outputs, and request revisions — is what separates a simple prompt from an autonomous build.
Where You Still Need a Human #
This is worth being direct about, because the “one prompt” framing can imply full automation when that’s not quite true.
Human review is still essential at three points:
After the business plan. The agent’s assumptions about your target customer, revenue model, and risk factors need to be validated against what you actually know. Especially the risks — an AI agent doesn’t know your specific competitive context, your existing relationships, or regulatory nuances in your industry.
After brand selection. Naming and brand direction are decisions that have long-term consequences. The agent gives you good options quickly. You still have to pick one and own it.
After the product spec. Before copy gets written, someone who actually knows how software gets built needs to review the feature set and integration dependencies. The agent is optimizing for coherence and customer value — not for what your current team can actually ship.
Everything else in the workflow can run without interruption. But those three checkpoints are real, and skipping them is where “build a company with one prompt” can produce a beautifully coherent hallucination.
How to Build This Workflow in MindStudio #
If you want to build this kind of multi-agent company-building workflow yourself, MindStudio is a practical place to start — especially if you don’t want to manage API keys, orchestration infrastructure, or rate limiting across multiple Claude calls.
The platform gives you access to Claude and 200+ other AI models in a single environment, with a visual builder that handles the agent chain logic without code. You define the agents, the inputs and outputs, and the dependency structure — MindStudio handles the execution.
For a workflow like this, you’d be building:
- An
intake agent that parses your
/goal
prompt into structured data - A business plan agent that uses Claude and outputs a defined schema - Parallel brand andproduct spec agents that each receive the business plan as input - A copy agent that merges the brand and product spec outputs - A media brief agent that generates video scripts from the copy - An optional media generation agent using the AI Media Workbench for actual image and video output
The whole workflow — from intake to final output — can be triggered by a single form submission or a webhook call. Which means your /goal
prompt can come from a Slack message, a web form, an email, or an API call from another system.
You can try MindStudio free at mindstudio.ai. Building the basic version of this workflow takes about an hour for someone who’s used a visual builder before.
For teams who want to go further — connecting the workflow to HubSpot for CRM, Notion for documentation, or Airtable for product tracking — MindStudio has pre-built integrations for all of those out of the box.
FAQ #
Can Claude actually run multi-agent workflows on its own?
Claude can act as an orchestrator within a multi-agent system, but it doesn’t manage the infrastructure layer itself. Tools like MindStudio or frameworks like LangChain or CrewAI handle the execution environment — routing messages between agents, managing state, handling retries. Claude reasons and produces outputs; the orchestration layer manages the flow.
How long does it actually take to build a company with one prompt?
In the experiment this article is based on, the full output — business plan, brand brief, product spec, landing page copy, and video scripts — was produced in under four hours. That’s total elapsed time including human review checkpoints. The actual compute time across all agents was under 20 minutes.
What’s the difference between a multi-agent workflow and a long prompt chain?
A prompt chain is linear: A produces output, which becomes B’s input, which becomes C’s input. A multi-agent workflow is a directed graph. Agents can run in parallel, merge inputs from multiple upstream sources, and loop back to previous steps when outputs fail validation. The orchestrator manages the graph; in a simple prompt chain, you manage the sequence manually.
Is the output actually usable, or does it need heavy editing?
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 depends on the step. Business plans and product specs usually need 20–30% revision — the structure is solid but the specifics need tuning. Copy tends to need 10–20% editing, mostly tone adjustments. Video scripts are often used almost verbatim. The business plan is where human judgment matters most; the copy is where the agent saves the most time.
What model works best for orchestrating multi-agent company builds?
Claude performs well at the orchestrator role because of its large context window and ability to produce clean structured outputs (JSON, Markdown) that downstream agents can parse reliably. GPT-4o is a solid alternative, especially for copy generation. For media generation steps, specialized models (image/video-specific) outperform general language models significantly.
Can this work for an existing business, or only for new company ideas?
It works well for existing businesses launching a new product line, entering a new market, or rebuilding a brand. The /goal
prompt format accepts constraints like “we already have X customers” or “we’re launching this as a spin-off of [existing brand]” — the agents incorporate those constraints throughout the downstream output.
Key Takeaways #
- A single structured
/goal
prompt can orchestrate a multi-agent workflow that produces a complete company foundation: business plan, brand, product spec, landing page copy, and launch video scripts. - The multi-agent architecture — not just a long prompt — is what makes this possible. Parallel execution, structured outputs, and dependency management across agents are the key mechanisms.
- Claude is effective as an orchestrator because of its context capacity and ability to produce schema-consistent structured outputs that downstream agents can reliably consume.
- Human review is still essential at three points: validating the business plan, selecting brand direction, and approving the product spec before copy generation begins.
- Tools like MindStudio let you build and deploy this kind of workflow without managing API infrastructure, with Claude and 200+ other models available in a single environment.
If you want to build your own version of this workflow — whether for a new company idea, a product launch, or an internal process — MindStudio is free to start and the core workflow described here can be built in an afternoon.