# smooth cross-vendor agent loops combining Claude Fable and GPT-5.5 Codex > Integrate Claude Fable as architect and GPT-5.5 Codex as builder for efficient, research-backed automation without extra API costs. > By Dave · 2026-06-13 > Source: https://otf-kit.dev/blog/architect-loop Automating code builds across AI agents used to mean slow, serial, and high-touch. That changes with the new Claude Fable GPT-5.5 Codex architect loop—a research-backed workflow that turns your flat-rate Claude Code and ChatGPT subscriptions into a cross-vendor, unattended, parallel build engine without extra API keys or token metering. It’s a disciplined loop: Fable architects every code slice and acceptance gate; Codex builds and researches, isolated and in parallel, for hours if needed. If you want AI-driven code generation you can actually trust—and scale—this is the pattern to watch. ## What is the Claude Fable GPT-5.5 Codex architect loop? The Claude Fable GPT-5.5 Codex architect loop is a cross-vendor, research-backed automation for AI-powered code generation and review, designed to run locally per repo and use your own paid AI subscriptions. The architecture assigns each agent a role and divides labor for quality and safety: - **Claude Fable** acts as **architect**—it designs each build slice, authorizes which files can change (acceptance gates), and judges the resulting output. - **GPT-5.5 Codex** takes the role of **builder and researcher**—it performs all engineering and web research, operating in parallel across isolated lanes. - The system runs on **existing Claude Code and ChatGPT paid plans**—**no additional API keys, no token-based billing.** - It is installed **per repo, not globally**, avoiding global npm drift or machine pollution. - This is an intentional, cross-vendor agent loop for disciplined AI coding workflows. By splitting “architect” and “builder” roles, the loop clarifies responsibility and ensures that only pre-authorized code paths are modified. Developers get reliable parallel builds, strict spec enforcement, and subscription-only cost control. Everything is sourced and versioned in the repo, using only the official architecture loop workflow: https://github.com/DanMcInerney/architect-loop ## How does the Claude Fable GPT-5.5 Codex architect loop workflow operate? The loop runs as a single **work block** at a time, emphasizing quality over throughput. Each work block has a clear cycle: **1. Judgment and spec**: The loop begins with a short Fable session. Fable does not write code; instead, it judges the output of the last run, then writes a formal spec and acceptance gates for the next proposed slice. Gates are committed before any builder sees them—enforced as read-only boundaries on file sets. ```bash # Example: Start a work block, judge last run, spec next slice, dispatch architect-loop judge architect-loop spec architect-loop dispatch ``` **2. Parallel isolated builders**: The spec is split into 1-4 “lanes” (disjoint sets of files), each independently buildable in isolation. Each lane runs a fresh Codex (xhigh) instance in its own `git worktree`. - **Builders must argue with the spec before building**—if they silently comply, it’s treated as a defect. - Each builder can only modify its declared files. Any edit outside its slice (especially in acceptance gate files) is an immediate failure. - Builders physically **cannot commit**; the sandbox protects these boundaries. Outputs are raw, for Fable’s judgment only. **3. Integration**: Fable judges builder results in a fresh session. Its review is cross-context—measurably stricter than same-session acceptance. Only if the code passes the spec (and the acceptance gates) does Fable commit and merge the result. - **Builder claims are hearsay**—Fable runs the acceptance gate commands itself and checks the diff. - Automated tests passing is not enough; code must match intent and be mergeable as judged by Fable. **4. Repo as memory**: All coordination, state, and history are kept in the repo itself—no memory leakage across runs, no shadow state. If it isn’t in the repo, it didn’t happen. **5. Supervision and safety**: - Sandboxed builds via `git worktree` per lane - Liveness/stall triage and explicit command timeouts on long builder runs - All session logs, diff, and gates documented and pruned per run This workflow enables safe and concurrent progress guarded by discipline, not trust. ![Fable designs and judges, gates set read-only files, parallel Codex builder lanes run in s](https://cdn.otf-kit.dev/blog/architect-loop/inline-1.png) ## What advantages does this cross-vendor loop offer developers? This architecture provides hard technical benefits: - **True parallelism, no merge conflicts**: Builders operate in separate worktrees and only on assigned file sets, making concurrent code slice development safe and efficient. - **No API key sprawl or new billing risks**: The loop runs on Claude Code and ChatGPT paid plans; no additional API keys, no per-token billing or hidden costs. - **Quality enforced by acceptance gates and specs**: Only pre-approved slices can be changed, and every build is judged before integration. - **Unattended, multi-hour runs**: Once launched, Codex can build and research in parallel for hours, freeing developer attention. - **Ideal for planning and exploration**: Generate experimental code slices for new features or architectures, using the cited report to feed your PRD. - **Automated, source-cited reporting**: Each run produces a report with source citations—everything the builder did is documented and auditable. This is a solid, research-driven workflow—much stricter than “just let the AI edit the repo”. It lets you scale AI-assisted code authoring with confidence (and an audit trail) instead of hoping a model “did the right thing”. ## How do you set up and use the Claude Fable & GPT-5.5 Codex loop today? You can run the architect loop on any repo, provided you meet these prerequisites: **Prerequisites** - **Claude Code** account with **any paid plan** - **Codex CLI** signed into a **ChatGPT paid plan** - Local, per-repo installation of the architect-loop (no global install) **1. Clone and install locally** ```bash git clone cd architect-loop npm install # or the repo’s preferred instruction ``` _The tool does not install globally—always run from inside the target repo._ **2. Initial preparation and config** - Setup your repo for worktree-based builds (`git worktree` must be available and enabled). - Ensure both Claude Code and Codex CLI are authenticated on your host, with the right plans. **3. Running a work block** Each cycle is explicit and serial: ```bash architect-loop judge # Fable judges the last builder output architect-loop spec # Fable writes the next slice spec + acceptance gates architect-loop dispatch # Codex builders build in parallel, raw results only ``` - **Monitor gates and outputs:** Acceptance gates are committed before the build. You can inspect which file sets are gated and what code slices get built. - **Debugging builder/spec disagreements:** If a builder disagrees with the spec, you’ll see explicit argument logs. A silent builder is a defect; disagreement is encouraged and logged. - **Builders never commit:** You must use `architect-loop` to accept and land any code. The sandbox (and git worktree isolation) makes this tamper-proof. - **Update your PRD from cited reports:** Each run produces a cited, auditable report—use this live research to revise or evolve your product spec. For specifics, the current workflow and requirements are fully documented in the [architect-loop GitHub repo](https://github.com/DanMcInerney/architect-loop). ## What limitations or considerations should users keep in mind? While capable, the loop isn’t frictionless or universal—here’s what to expect: - **Git worktree literacy required:** You need to understand isolated worktrees and CLI operations; it’s not plug-and-play for a GUI workflow. - **Serial work blocks:** Only one work block runs at a time. Fully continuous integration is not built-in yet. - **No builder commits:** Builders can’t merge code by themselves. All integration relies on Fable’s AI judgment (with human supervision on sensitive projects). - **Subscription plans needed:** Claude Code and Codex both require paid plans—this is not free-tier tooling. - **Early-phase focus:** Best used for project design, planning, and exploring new slices—not for at-scale, production code merges. - **Setup and learning curve:** Expect some initial ramp as you configure gating, worktrees, and spec tuning. In short: it’s built for research-driven teams, product architects, or devs piloting new features—not yet a drop-in for full CI/CD or legacy monorepos. ## Future outlook and potential enhancements for architect loop workflows The cross-vendor architect loop is early, but extensible. - **More agent integration**: The architecture could accommodate additional AI builders as they become available. - **Better specs and gates**: Expect tighter spec languages and richer acceptance gates—potential for custom logic in gate definitions. - **CI/CD integration**: Incorporating architect-loop actions into continuous deployment flows for automated, gated merges. - **Richer reporting and code review**: Enhanced, AI-powered reports; code review surfaced as first-class artifacts. - **Broader community adoption**: As cross-vendor agent APIs and tools mature, contributions from other agent builders will broaden supported scenarios. All of these are natural paths forward—value compounds as workflows and reporting get more expressive. ## The bottom line: parallel, cross-agent AI code builds with discipline—no billing trap The Claude Fable GPT-5.5 Codex architect loop is a new template for AI-driven, automated code builds: no token counting, strict file gating, parallel isolated builders, and research-cited PRD enrichment—all on paid Claude Code and ChatGPT plans you already use. If you’re exploring code architectures or running experimental builds, it turns your repo into a provably safe, auditable playground with hard boundaries and reproducible research—no surprise bills, no silent AI drift. For developers demanding clarity, safety, and modern AI-assisted code, this is an important shift in workflow. The foundation—a repo-local, cross-vendor loop powered by strict architectural discipline, not trust—positions your stack for the next era of code generation tools. Start small, understand the spec/gate dance, and you’ll enable safe, concurrent builds and actual research feedback for your product cycles.