Architecting Multi-Agent Orchestration: Implementing a Manager-Engineer Split using Fable 5 and GPT 5.6

The current frontier of Large Language Model (LLM) utilization is shifting away from single-prompt inference toward complex, multi-agent orchestration. The limitation of relying on a single model—regardless of its parameter count or reasoning capabilities—is the inherent conflict between high-level strategic planning and low-level technical execution. To achieve true autonomy in complex workflows, one must implement an architectural split: utilizing a "Manager" model for oversight, validation, and task decomposition, and an "Engineer" model for code generation and implementation.

This post explores the deployment of this dual-model architecture using Fable 5 (Anthropic) as the strategic orchestrator and GPT 5.6 (OpenAI) via the Codex CLI/Claude Code interface as the execution engine.

The Architecture: Managerial Oversight vs. Executional Engineering

The core of this system relies on a separation of concerns. In this framework, we define two distinct roles:

1. The Manager (Fable 5): This model is responsible for high-level logic, task segmentation, and rigorous quality assurance (QA). It does not write the implementation code; instead, it breaks down complex objectives into discrete, actionable briefs. Crucially, Fable 5 acts as a gatekeeper, reviewing every output from the engineer to ensure compliance with the original mandate.
2. The Engineer (GPT 5.6 via Codex CLI): Running within a terminal environment through codex exec, this model is optimized for high-throughput coding and tool manipulation. It receives briefs from Fable 5 and executes them, often running multiple "Sol" workers in parallel to handle independent tasks simultaneously.

By decoupling planning from execution, we mitigate the "pitbull" effect—a phenomenon where highly capable models like GPT 5.6 become overly eager, executing instructions with high velocity but occasionally cutting corners or hallucinating unrequested features. Fable 5 provides the necessary heuristic oversight to catch these regressions before deployment.

Implementation via Model Context Protocol (MCP)

The power of this dual-model setup is amplified when integrated with the Model Context Protocol (MCP). By connecting the agentic workflow to external MCP servers, we extend the models' capabilities beyond text generation into real-world tool manipulation:

• Appify: For automated web scraping and lead extraction from Google Maps API.
• Arcads: For programmatic video generation, creating dynamic hero assets for web deployment.
• Vercel: For automated CI/CD pipelines to push generated sites live.
• Alpaca API: For interfacing with real-time market data and executing trades in a paper trading environment.

Use Case I: Autonomous Web Agency Pipeline

In an autonomous agency workflow, the system executes a full-funnel deployment pipeline. The process begins with Fable 5 utilizing Appify to scrape local business data (e.g., healthcare providers in Tampa, FL) and filtering for specific criteria: high ratings ($\ge$ 4.3), significant review counts ($\ge$ 40), and missing or broken web presences.

Once the lead list is curated, Fable 5 briefs multiple GPT 5.6 "Sol" workers in parallel. Each worker is tasked with building a single-page responsive site. The pipeline integrates Arcads to generate unique, AI-driven hero videos for each business, ensuring no two sites appear as generic templates. Finally, the system deplochs these via Vercel.

The critical technical advantage here is the Review Loop. During testing, Fable 5 identified instances where GPT 5.6 incorrectly flagged live websites as broken due to loading timeouts. Fable 5 intercepted this error, updated the engineer's brief with a new rule ("A business with a working website must never be reported as broken"), and forced a re-run of the failed tasks.

Use Case II: Agentic Productivity Auditing

Beyond outward-facing services, this architecture can be turned inward to optimize human workflows. By deploying an agent that monitors system activity (via periodic screenshots and window title logging), Fable 5 can perform a deep-dive audit of time allocation.

The workflow follows a specific loop:

1. Observability: A Python script captures the foreground application and window titles every 10 seconds, excluding sensitive directories (e._g., banking/password managers).
2. Analysis: Fable 5 parses the logs to identify "leaks"—repeated patterns of context switching or unproductive dashboard checks.
3. Remediation: Once a pattern is identified as costing significant time-value, Fable 5 briefs GPT 5.6 to build an automated patch (e.g., a system notification that intercepts frequent, non-essential window switches).

Use Case III: Algorithmic Risk Management and the "Mandate" Pattern

The most sophisticated application of this architecture is in high-stakes environments like algorithmic trading. Here, the separation of concerns becomes a matter of risk mitigation.

In this setup, we use Alpaca for paper trading. The architecture is strictly partitioned:

• Fable 5 (Risk Manager): Writes a "Risk Mandate"—a binding set of constraints including maximum position size, hard daily loss caps, and an approved ticker list. It does not touch the market; it only reviews code against this mandate.
• GPT 5.6 (The Bot/Executor): Develops the trading logic (e.g., a trailing stop-loss bot) that must strictly adhere to the mandate's parameters.

The technical "hard wall" is implemented such that if any line of generated code contradicts the Risk Mandate, Fable 5 rejects the deployment entirely. This prevents the common failure mode in AI trading where models chase volatility or exceed leverage limits due to a lack of disciplined oversight.

Conclusion: The Model-Agnostic Future

The ultimate takeaway is that this architecture is model-agnostic. While we utilized GPT 5.6 and Fable 5, the pattern remains valid regardless of which model holds the "Manager" or "Engineer" role. As new models (like Kimmy or various open-source iterations) emerge, they can be swapped into the pipeline to optimize for cost, speed, or reasoning depth. The future of AI automation lies not in finding a single "perfect" model, but in mastering the orchestration of specialized agents within a structured, verifiable framework.