# How to Use Fable 5 as Architect and Grok 4.5 as Construction Crew in Multi-Agent Workflows > Source: > Published: 2026-07-09 00:00:00+00:00 # How to Use Fable 5 as Architect and Grok 4.5 as Construction Crew in Multi-Agent Workflows Use frontier models for planning and cheaper models for execution. This real example built a 50-district 3D city for $8 using this split-model pattern. ## The Split-Model Pattern That Actually Saves Money Most people building multi-agent workflows make the same mistake: they use one model for everything. Either they pick a powerful frontier model and watch their API bill climb, or they pick a cheaper model and wonder why the output quality is inconsistent. There’s a better way. The architect/crew pattern splits your workflow into two roles: a high-reasoning model that plans and a faster, cheaper model that executes. Applied correctly, this approach cuts costs dramatically without sacrificing quality on the parts that matter. Multi-agent workflows built this way can complete complex tasks — like generating an entire procedural 3D city — for a fraction of what a single-model approach would cost. This guide walks through exactly how to set this up using Fable 5 as your architect and Grok 4.5 as your construction crew, with a real example that built a 50-district 3D city for $8. ## What the Architect/Crew Pattern Actually Means The core idea is simple: not every task in a workflow requires the same level of reasoning. Planning, decision-making, and quality control need deep thinking. A model handling these needs to understand context, anticipate failure modes, and produce structured instructions that downstream agents can follow without ambiguity. That’s the architect role. Execution is different. Once you have a clear spec, generating the actual output — writing code, creating content, building data structures — is largely repetitive and mechanical. That’s the crew role. ## Other agents ship a demo. Remy ships an app. Real backend. Real database. Real auth. Real plumbing. Remy has it all. When you charge a frontier model with both jobs, you’re paying premium rates for work that doesn’t need premium reasoning. The architect/crew split means your expensive model only runs when it needs to. ### Why This Matters at Scale Consider a task that requires generating 50 unique districts for a 3D city, each with different architecture styles, population density, road networks, and terrain. If your frontier model generates each district from scratch, you’re paying for 50 high-cost inference calls on content that follows a predictable template. But if your frontier model produces the district specifications — the schema, the constraints, the style guide, the per-district parameters — and hands those off to a faster model to generate the actual output, you’ve shifted 90% of your token spend to cheaper inference without losing the strategic quality that makes the output coherent and consistent. ## Why Fable 5 Works as the Architect Fable 5 is built for structured reasoning tasks. It excels at: **Producing hierarchical plans**— breaking complex problems into discrete, ordered steps that downstream agents can follow** Schema generation**— defining output formats that ensure consistency across hundreds of execution calls** Constraint reasoning**— understanding what constraints should apply and encoding them into instructions rather than checking output after the fact**Self-critique**— identifying gaps in a plan before execution begins, which reduces the rate of failed or hallucinated outputs downstream For the 3D city example, Fable 5’s job was to produce a master specification document: district archetypes, a consistent coordinate system, naming conventions, style rules, and a parameterized template that Grok 4.5 could fill in for each district. That spec generation cost roughly $0.80 in tokens. The rest of the $8 went to 50 district generation calls. ## Why Grok 4.5 Works as the Construction Crew Grok 4.5 from xAI is fast, cost-efficient, and capable on structured tasks. When given a clear spec and a template, it produces reliable outputs with low error rates. That’s the key phrase: *when given a clear spec*. Grok 4.5 doesn’t need to figure out what a district should look like — Fable 5 already decided that. It just needs to fill in the template correctly, and it does that well. For execution-heavy workflows, Grok 4.5 offers: **Low cost per call**— significantly cheaper than frontier models on a per-token basis** Fast inference**— parallel calls resolve quickly, which matters when you’re running 50+ agents** Strong instruction-following**— when the prompt is structured and clear, output consistency is high** JSON/structured output support**— critical for feeding outputs into downstream systems or 3D rendering pipelines The combination works because each model is doing what it’s best at. ## The 3D City Example: How It Was Built for $8 Here’s a concrete walkthrough of how the 50-district city was built using this split-model workflow. ### Step 1 — Fable 5 Generates the Master Spec The architect call is a single prompt asking Fable 5 to design the city’s structure. The prompt includes: - The desired output format (JSON spec) - High-level constraints (50 districts, procedural variation, no two districts identical, must be renderable in a specific 3D engine) - Style parameters (cyberpunk aesthetic, elevation variance, road density rules) Fable 5 returns a master spec with: - 50 district definitions (name, archetype, coordinates, elevation range, density index, road network type) - A reusable district generation template with clearly marked variable slots - Rendering constraints per district type - A global style guide **Token cost:** ~$0.80 ### Step 2 — The Orchestrator Parses the Spec A lightweight orchestration layer (in this case, a simple script) reads the master spec and creates 50 individual job payloads — one per district. Each payload contains: - The district-specific parameters from Fable 5’s spec - The filled-in generation template for that district - Any constraints specific to that district type This is pure data transformation, no model inference needed. ### Step 3 — Grok 4.5 Builds Each District The 50 job payloads are dispatched to Grok 4.5 in parallel. Each call asks Grok 4.5 to generate: - The full 3D geometry spec for that district (building placements, road nodes, terrain mesh parameters) - Texture and material assignments per building type - Lighting and atmosphere parameters - Metadata for the rendering pipeline Because the template is clear and the constraints are embedded in the prompt, Grok 4.5 produces structured JSON output with high consistency. Failure rate across 50 calls: under 4%, and those failures were retried automatically. **Token cost:** ~$7.20 across 50 calls ### Step 4 — Fable 5 Does Final Quality Review One additional architect call reviews a sample of the district outputs for coherence — checking that adjacent districts don’t share identical building layouts, that coordinate systems are consistent, and that style constraints were respected. This review call catches any outliers and returns a list of corrections. It adds roughly $0.15 to the total cost. **Total cost: ~$8.15 for a fully specified 50-district 3D city.** ## How to Set Up This Pattern in Your Own Workflow ### Define the Split Before You Build Before writing any prompts, write down two lists: **Architect tasks**— decisions that require understanding the whole system, producing structured plans, or setting constraints** Crew tasks**— execution that follows a clear template, is repeatable, and doesn’t require strategic judgment If a task is in the first list, route it to your frontier model. If it’s in the second, route it to your cheaper execution model. ### Design the Spec as a First-Class Output Most workflow builders treat the plan as a means to an end. Treat it as a product. The spec your architect model produces is the most important artifact in your workflow — it determines the quality ceiling of everything that comes after. Design your architect prompt to produce: - A schema your execution model can parse without ambiguity - Variable slots that are clearly labeled - Constraints expressed as rules, not guidelines - A template that doesn’t require interpretation ### Use Parallel Execution for Speed One of the main advantages of the crew model is that you can run many calls simultaneously. Structure your orchestration layer to dispatch parallel requests rather than sequential ones. For the 50-district example, parallel execution reduced total generation time from roughly 15 minutes to under 3. ### Build in a Retry Layer Even a well-prompted execution model will occasionally produce malformed output. Build automatic retry logic at the orchestration layer. A simple check — does the output parse as valid JSON? does it contain the required fields? — catches most failures before they propagate. ## 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. ### Know When to Loop Back Some workflows benefit from a second architect review after execution. Add this step when: - Outputs need to be coherent across multiple crew calls (like adjacent districts in a city) - You’re generating content that will be used in a downstream system with strict requirements - The stakes of a bad output are high enough that catching errors before delivery matters ## Building This on MindStudio MindStudio’s visual workflow builder is well-suited for implementing the architect/crew pattern without having to wire up the orchestration infrastructure yourself. You can set up a workflow where: - A Fable 5 step handles the architect call and outputs a structured spec - A loop or parallel dispatch block passes individual job payloads to Grok 4.5 steps - A conditional retry block handles failures automatically - An optional final Fable 5 step runs quality review MindStudio gives you access to 200+ models — including Grok variants and frontier reasoning models — without needing separate API accounts or managing rate limiting yourself. You pick the model per step, which is exactly what this pattern requires. The visual builder makes it easy to see which parts of your workflow are running expensive inference and which are running cheap execution — useful when you’re trying to optimize cost without rebuilding the whole pipeline. You can try MindStudio free at [mindstudio.ai](https://mindstudio.ai). If you’re building more complex multi-agent systems, MindStudio also supports [agentic workflows that run on a schedule](https://mindstudio.ai) and webhook-triggered pipelines, which pair well with this pattern when you need to process large batches of jobs automatically. ## Common Mistakes to Avoid ### Making the Architect Prompt Too Vague If your architect model produces a spec that’s ambiguous, your execution model will interpret that ambiguity inconsistently across calls. Tighten the architect prompt until the output spec leaves no room for interpretation on the execution side. ### Skipping the Spec and Going Direct to Execution It’s tempting to skip the spec step and just ask your execution model to generate output directly. This works for simple tasks but breaks down as complexity scales. By district 30 of 50, you’ll have inconsistencies that are expensive to fix. ### Using the Same Model for Both Roles Even if budget isn’t a concern, using the same model for both architect and crew steps removes a useful quality gate. The act of producing a spec, then consuming it, creates a natural error-catching layer. When one model does both, that layer disappears. ### Not Logging Architect Outputs Save your architect outputs. When something goes wrong in execution, having the spec lets you debug whether the problem was in planning or execution. Without it, you’re guessing. ## FAQ ### What is the architect/crew pattern in multi-agent workflows? It’s a workflow design approach where you assign different model tiers to different roles. A higher-reasoning “architect” model handles planning, spec generation, and quality control. A faster, cheaper “crew” model handles repetitive execution tasks. The split reduces cost without sacrificing output quality on the decisions that matter. ### When should I use a frontier model vs. a cheaper model? ## Plans first. *Then code.* Remy writes the spec, manages the build, and ships the app. Use a frontier model when the task requires understanding the whole system, making decisions that affect downstream steps, producing a plan or schema, or catching errors that would be costly later. Use a cheaper model for tasks that follow a clear template, are repetitive, or don’t require strategic judgment. ### How much can the architect/crew pattern save on API costs? It depends on your use case, but savings of 60–90% compared to running everything through a frontier model are achievable on tasks with high execution volume. The 3D city example achieved roughly 90% of the work for 10% of what a frontier-model-only approach would cost. ### Does this pattern work for non-creative tasks like data processing or coding? Yes. The pattern applies wherever you have planning tasks and execution tasks that can be separated. Code generation workflows, data transformation pipelines, report generation, and content production all benefit from this split. The architect produces the structure, schema, or approach; the crew generates the actual output. ### What’s the hardest part of implementing this pattern? Designing the spec interface — the output your architect model produces and your execution model consumes. If this handoff is unclear or ambiguous, execution quality drops. Most of the design work should go into making this interface clean and unambiguous. ### Can I use different model providers for the two roles? Yes, and often you should. Using a model from one provider for planning and a model from a different provider for execution is common. The only requirement is that your orchestration layer can call both APIs, which most workflow platforms — including MindStudio — handle natively. ## Key Takeaways - The architect/crew pattern assigns high-reasoning frontier models to planning and cheaper models to execution — reducing cost without sacrificing quality where it counts. - Fable 5’s strength is producing hierarchical specs and structured plans; Grok 4.5’s strength is fast, consistent execution against those specs. - The 50-district 3D city example demonstrates the pattern at real scale: $0.80 for architecture, $7.20 for 50 parallel execution calls, $8 total. - The quality of the spec — the handoff document between architect and crew — determines the ceiling of your workflow’s output quality. Design it carefully. - Parallel execution, automatic retries, and optional review loops make this pattern robust enough for production use. If you want to build this kind of multi-model workflow without managing infrastructure, [MindStudio’s no-code builder](https://mindstudio.ai) lets you assign different models to different steps, run parallel dispatches, and connect everything in a single visual canvas. Start free and see how far you get.