smooth cross-vendor agent loops combining Claude Fable and GPT-5.5 Codex

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.

# 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.

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

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:

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.

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.