Claude Fable and GPT-5.5 Codex power a smooth cross-vendor agent loop

Developers have spent years cobbling together agent loops across vendors, juggling API keys, variable pricing, and a tangled mess of ephemeral memory. The architect-loop project changes this calculus: it fuses Claude Fable’s discipline as an architect with GPT-5.5 Codex’s brute-force engineering and web research, running a slice-by-slice development loop entirely on your existing flat-rate subscriptions. There are no extra API keys, no surprise token bills. Everything is scoped, auditable, and repo-local. If you want to build autonomous agents that spec, research, build, and judge code slices in the open—cross-vendor, parallel, and hands-off—this is the real-world template.

Let’s break down what makes architect-loop actually work, how it puts the Claude Fable and GPT-5.5 Codex duo to use, and—critically—how you can run it on your own repo in about five minutes.

What is the architect-loop Claude Fable GPT-5.5 Codex integration?

At its core, architect-loop is a research-driven agent orchestration loop, using two purpose-built Claude Code skills:

• Claude Fable acts as architect: it writes structured specifications (one slice at a time), explicitly sets acceptance gates, and judges results post-build.
• GPT-5.5 Codex serves as builder and researcher: it executes code changes and parallel web research, isolated per “lane”, and reports raw diffs and research summaries.

Unlike “all-in-one” autonomous agents that guess intent or invent process, architect-loop enforces a closed loop:

1. Spec phase: Fable defines exactly what should be built—one meaningful slice per work block—splitting the work into disjoint sets of files (lanes).
2. Quality gates set: Fable commits acceptance gates (read-only files or criteria), frozen before any building begins. If a builder modifies a gate file, it’s an instant fail.
3. Parallel build + research: Codex runs isolated worktrees, one per slice lane. Each builder is sandboxed, must challenge the spec, and only reports code or findings—no direct commits.
4. Judgment: Fable reviews the resulting diffs/outputs against the original intent, not just test results, then merges or rejects.

There are no API keys or incremental token bills. All interaction is on your paid Claude Code and OpenAI ChatGPT subscriptions, with everything local to your repo. Run the loop and you get repeatable, gateable, cross-vendor agent work as an auditable Git history.

How does Claude Fable architect the development slices?

Claude Fable isn’t just a naming flourish—it’s the central controller that keeps autonomous agents honest and work repeatable. Here’s how it owns the architecture loop at every step:

• Designing the spec: On each run, Fable creates a “one-pull-request” spec. Instead of sprawling, ambiguous goals, you get a sharply-defined slice, split into 1-4 lanes, with each lane restricted to a disjoint subset of files. This prevents accidental collisions and turns ambiguous stories into tractable engineering units.
• Freezing the gates: Before any builder code runs, Fable configures all acceptance gates as read-only files (or other immutable criteria). If any builder tampers with a gate file, the slice fails outright.
• Isolation by design: Because every lane is defined up front, builders cannot “leak” across boundaries or accidentally mesh changes. When architect-loop dispatches builds, each one gets a unique, isolated git worktree. There’s simply no path for accidental cross-contamination or side effects.
• Judgment and merge: Once all builder and research results are in, Fable runs again—this time in a fresh session. Only at this point are the builder’s claims, output diffs, and research summaries reviewed. Test results aren’t enough—Fable checks that the actual intent of the spec was delivered before merging. This cross-context, cross-session structure means every code merge has survived both up-front gate design and post-build critical review.

Takeaway: With Fable in the architect role, you know what gets built, who builds it, where the boundaries are, and why it passed. You get durable, explainable autonomy.

What is GPT-5.5 Codex’s role as builder and researcher?

Architect-loop’s real punch comes from Codex’s dual role—code generation and in-the-wild research—multiplied across parallel “lanes.” Here’s what that enables:

• One builder per lane: For every lane Fable defines, Codex spins up a new isolated builder, each in a fresh, high-privilege git worktree. Each builder only has access to its own declared files. The sandbox physically prevents it from writing outside its bounds or making commits.
• Research-first by default: Every builder launches both code modifications and a research thread (think: “go deep on this domain, track down canonical sources, find key papers and precedents”). This loop runs unattended for hours—with no manual approvals or context switching—making it feasible to genuinely learn or refactor, not just autocomplete.
• Must-argue protocol: Codex isn’t a code dummy; every builder must argue with the spec before building. That means it can push back, raise doubts, or ask for clarifications—silent compliance is flagged as a probable defect.
• File-bounded changes: Builders can only modify their declared files. Touch a gate file, or go off-piste, and it’s a hard stop fail.
• Reporting, not committing: All outputs—code diffs, research notes—are passed upstream. No builder can directly alter the repo: judgment and merges happen later, in Fable’s session.

Practical upshot: You get safe, parallel, research-heavy autonomous engineering, without ceding entire codebases to unreliable “auto-commit” agents or risking expensive API misfires.

How to use the architect-loop today on your GitHub repo

Here’s how to get architect-loop actually running—locally, auditable, and zero-globals. No convoluted setup, just two paid subscriptions and one repo-local install.

Prerequisites

You need:

• Claude Code: Any paid Claude plan, with the Code skill enabled.
• Codex CLI: Installed and signed into a ChatGPT plan on the machine running the builds.
• A local Git repo: Architect-loop installs to the current repo only, keeping its scope tight.

Install steps

# 1. Ensure your repo is clean and committed

git status
# should show only tracked files, no pending changes

# 2. Install Claude Code and Codex CLI as per vendor docs
# (assume those are installed)

# 3. Install architect-loop to your local repo only
git clone 
cd architect-loop/
# Or follow any install script in the repo for local-only setup

# 4. Initiate a work block loop
./architect-loop run

The work loop

• Fable session: The tool launches a short, spec-&-judge session with Fable, which
  • Judges the last run (merging or failing lanes)
  • Specs a new PR slice, freezing gates and splitting lanes
• Parallel builder dispatch: Codex launches 1–4 builder lanes in parallel, each isolated in its own worktree. They perform code modification and web research autonomously, respecting bound files.
• Output review: Results (diffs, research logs) are surfaced directly in the CLI or saved to a report file. Gate fails (e.g., edits to protected files) get flagged.
• Manual triggers: You can rerun or respec at any time; nothing runs globally or outside your repo.

Common gotchas

• Subscription required: Both skills require active paid subscriptions—this isn’t a free-loop starter.
• Local only: Architect-loop only installs to one repo at a time; it cannot be globally enabled across orgs.
• Gate strictness: Acceptance gates are hard boundaries—if even one test or file violation occurs, that lane is nixed for the run.

Tip: Use the cited report from each work block to feed your next PRD or slice decision. You get concrete, artifact-backed recommendations—not hand-wavy “maybe” summaries.

What are the benefits and use cases of architect-loop for developers?

This agent loop isn’t a toy. It fills real gaps for developers building with serious autonomy and safety constraints:

• No secret keys, zero surprise bills: Architect-loop uses your existing flat-rate Claude and OpenAI subscriptions. No new tokens, no usage-based invoices, no nightmare key sprawl.
• Repeatable, slice-driven autonomy: The single-slice, multi-lane structure gives you both parallelism and high auditability. Every gate is frozen before the build—no shifting success criteria.
• Research as first-class citizen: Codex’s default web research means you get code and context, citations, precedent papers, and OSINT—all verifiable, all self-contained.
• Fail-fast, test-first: Violations (like erred file edits or failing gates) fail fast with hard boundaries. This means less debugging of ambiguous agent merges after the fact.
• Top use cases:
  • Open-source projects needing high-assurance, parallelized development
  • Internal tools where audit trails and minimizing cloud leakage matter
  • AI research projects requiring deep, cited literature reviews or structural prototypes before commitment

Bottom line: Architect-loop enables hands-off, cross-vendor, multi-threaded AI engineering with real guardrails—ideal for lean teams and skeptical leads alike.

What are the current limitations and future prospects of the architect-loop?

No system lands fully formed, and architect-loop is honest about its scope and constraints:

• Not free: Claude Code and Codex CLI both require paid subscriptions (no free tiers).
• No global install: You must install architect-loop per repo; there’s no organization-wide toggle or integration.
• Slice-by-slice only: The loop is optimized for one slice at a time—not a full monorepo workflow.
• Single builder type: Currently, only Codex GPT-5.5 is supported as a builder; no plug-and-play for alternative LLMs yet.
• Supervision robustness only local: While supervision, timeouts, and stall triage are built in, scaling across huge orgs is not the goal for now.

What’s next? The project’s design leaves clear room for:

• Multi-architect or multi-judge support (e.g., getting a human in the loop, federated architectures)
• Support for more builders (Claude Code as builder, or additional LLMs)
• Global installation and broader agent collaborations
• Enhanced artifact reporting or structured, persistent logs for compliance or regulatory needs

Track updates and contribute ideas at github.com/DanMcInerney/architect-loop.

What this enables for OTF builders

If you want autonomy, speed, and guardrails—this model of cross-vendor, repo-local agent orchestration is a durable baseline. Architect-loop provides the slice isolation, gating discipline, and judge/builder split that most AI dev flows need. The loop is the durable context; the agents and vendor LLMs are the tools that change. Builders can slot in the newest Codex or Fable model without turning their codebase into quicksand.

Building on OTF’s foundation means you can use the best AI for each job, but keep the primitives—slice, gate, review, merge—constant. Architect-loop isn’t the end of agent loops, but it’s the first that treats your codebase as an asset, not a disposable plaything. There’s no “agent took the wheel and drove off a cliff” in your commit history—just auditable, PR-disciplined blocks.

In sum: If you’re serious about cross-vendor agent coding, architect-loop—Claude Fable for strategy, GPT-5.5 Codex for brute force—gives you hands-off, parallel, fully-enforced builds on top of subscriptions you already use. Run the loop, and scale your intent.