A clear pattern has emerged in how organizations architect their AI coding systems, and it reveals a fundamental divide between how large enterprises and smaller companies approach autonomous code generation. Internal platforms at companies like Stripe, Meta, Uber, and Shopify rely on deterministic pipeline architectures with explicit human approval gates, while commercial products targeting the broader market tend to favor handoff orchestrators that give AI agents near-total autonomy over execution.

What Is an AI Coding Orchestrator, and Why Does It Matter?

An AI coding orchestrator, also called a software factory, is a cloud-based system that takes a high-level intent like "fix this bug" or "investigate this log spike" and runs it through one or more AI coding agents to completion without a developer actively steering the process. At a certain point in an organization's AI adoption journey, this kind of automation becomes essential for scaling beyond what individual developers can handle.

Researchers analyzing sixteen publicly documented orchestrators found a striking pattern: the architecture choice correlates almost perfectly with whether the tool is built internally or sold commercially. This isn't coincidental. It reflects fundamentally different risk tolerances, operational maturity, and use cases.

Why Do Enterprise and Commercial Approaches Diverge So Sharply?

Internal platforms at large organizations cluster heavily on the pipeline side of the spectrum. Stripe's Minions, Shopify's Roast, Uber's LangFX, Meta's Confucius, Coinbase's NodeSmith, Google's migration pipeline, and Airbnb's batch migration pipeline all follow the same underlying shape: deterministic steps with AI agent calls and human-in-the-loop (HITL) approval gates interleaved throughout execution.

The pipeline languages vary. Shopify uses a Ruby domain-specific language called Roast with named cogs. Meta uses a directed acyclic graph (DAG) with HITL gates between stages. Uber uses LangGraph and Python. But the architectural principle remains constant: humans retain explicit control over decision points, and the system executes as a state machine rather than letting an AI agent improvise the entire workflow.

Commercial products, by contrast, predominantly embrace the handoff model. Conductor, Sculptor, Nimbalyst, Warp Oz, OpenHands, and Devin Desktop all dispatch an AI agent and let it determine the steps needed to complete the task. The orchestrator provides the initial prompt and context, then the agent figures out what to do.

Two commercial products break this pattern: Factory Droid and Augment Code. Both target enterprise structured workloads and expose real pipeline design capabilities. Augment Code, for instance, ships a coordinator, specialist, and verifier architecture with explicit scope-approval HITL gates, making it an exception in the commercial landscape.

How Do Organizations Choose Their Agent Architecture?

Beyond the pipeline versus handoff split, orchestrators differ in how they relate to the underlying AI coding agent. Three patterns dominate:

• Proprietary Agent Harness: The orchestrator ships its own custom agent. Block built Goose, Meta built Confucius, and Stripe forked Goose into Minions. On the commercial side, Factory Droid runs Droid and Augment Code runs Auggie. This approach gives organizations full ownership and control over the agent's behavior and maintenance.
• Bring-Your-Own Direct: The orchestrator dispatches a third-party agent harness untouched, with native execution and no interception. Airbnb runs Claude Code as-is, Coinbase mixes harnesses through Mux, and commercial products like Conductor, Sculptor, Nimbalyst, OpenHands, and Devin Desktop all pass the chosen harness through using the Agent Coordination Protocol (ACP) standard.
• Bring-Your-Own Wrapped: The orchestrator runs the chosen agent inside its own context and memory layer. Warp Oz adds "Agent Memory" and "Skills" on top of execution, while Augment Code layers structured context including system prompts and workspace metadata. This approach can degrade the inner agent's capabilities, so organizations need to verify performance before depending on it.

Internally, six of the eight platforms analyzed have consolidated on a single agent harness across the entire organization: Goose at Stripe and Block, Claude Code at Anthropic and Airbnb, Confucius at Meta, and LangFX at Uber. Polyglot agent harnesses are rare inside large organizations. On the commercial side, the split is more diverse: five products use bring-your-own direct, two use bring-your-own wrapped, and one uses proprietary.

When and How Do Humans Actually Intervene?

The orchestrator-to-human interaction pattern has largely settled on Slack, Linear, and other external tools rather than chat-in-dashboard interfaces. But when humans intervene during execution remains a deeper question with three distinct approaches:

• Confidence-Driven Intervention: The agent grades itself, a verifier sub-agent grades the work, or the user sets sensitivity dials. Meta's KernelEvolve, Augment Code's verifier role, and Devin's auto-review all use this approach. The downside is opacity; users tune indirectly by enriching context rather than setting explicit thresholds.
• Single-Gate Approval: One human intervention point, otherwise autonomous. This splits into two variants: upfront plan-approval (Cursor's long-running agents, Augment Code's scope approval, Devin's preflight checklist) and exit-only PR review (Copilot Coding Agent, Stripe Minions, OpenHands headless). Upfront approval catches direction errors before compute spend; exit-only reuses existing code review processes.
• Hook-Driven Control: The adopter writes scripts or configuration that fires at named execution milestones like pre-plan, pre-tool-call, post-tool-call, or pre-commit. The script can halt the agent, modify state, or run guardrails. OpenHands' hooks.json is the canonical declarative version; Claude Code ships its own hook system. Hooks are the lowest-level, most flexible surface but push the work onto the user.

These three approaches aren't equivalent in coverage. Confidence-driven is opaque. Single-gate is binary. Hook-driven is fully programmable but requires users to write code.

How to Evaluate an AI Coding Orchestrator for Your Organization

• Assess Your Risk Tolerance: If you operate at scale and need explicit control over autonomous execution, a deterministic pipeline architecture with HITL gates is likely safer than a handoff model. If you're a smaller team or startup, a handoff orchestrator may offer faster time-to-value with acceptable risk.
• Clarify Your Agent Strategy: Decide whether you want to build and maintain a proprietary agent, use a third-party agent directly, or wrap a third-party agent with your own context layer. Each choice has different maintenance and performance implications.
• Define Your Intervention Model: Determine when humans need to intervene. Do you want confidence-driven auto-review, a single approval gate, or programmable hooks at specific execution points? Your choice should align with your team's capacity and your tolerance for autonomous execution.
• Evaluate Agent Consolidation: Large organizations benefit from consolidating on a single agent harness across teams. This reduces operational complexity and makes it easier to optimize performance and security at scale.

The emerging software factory market reveals that there is no one-size-fits-all approach to AI coding orchestration. The divide between internal and commercial tools reflects genuine differences in how organizations operate at different scales. Large enterprises with mature DevOps practices and significant engineering resources can afford the upfront investment in deterministic pipelines with explicit gates. Smaller organizations and startups benefit from the simplicity and speed of handoff orchestrators, even if they sacrifice some control.

As the market matures, expect to see more commercial products adopting pipeline-style architectures and more internal platforms experimenting with handoff models for specific use cases. The key insight is that the orchestrator you choose should match your organization's maturity, risk tolerance, and engineering capacity, not the other way around.