Two Architectures of AI Coding Agents: Model-Native Agents vs. External Orchestration Frameworks

    This article compares the two dominant architectures behind AI coding agents: the model-native agent and the large-model-plus-external-orchestration framework. It examines their differences across three dimensions—underlying architecture, control philosophy, and permission model—and explains the representative "dual-agent" pattern that enforces a strict separation between planning and execution. It also offers guidance on choosing between the two approaches for different scenarios, along with general engineering best practices such as least privilege, human-in-the-loop oversight, verification loops, and persistent context.

    Introduction: Why the Architectural Choice Defines an AI Coding System’s “Personality”

    As AI-assisted programming tools evolve rapidly, one easily overlooked yet critical question emerges: where exactly does a system’s intelligence “live”? Is autonomous decision-making built directly into the model itself, or is a separate scheduling and control layer wrapped around the model? This is not merely a difference in implementation detail—it is a fundamental dividing line that determines a system’s control philosophy, reliability boundaries, and the way humans collaborate with it. This article focuses on two mainstream technical approaches—the model-native agent and the large-model-plus-external-orchestration framework—analyzing them across three dimensions: underlying architecture, control philosophy, and permission model. It then offers recommendations for choosing between them across different scenarios.

    The One-Sentence Answer: Who Holds the Wheel

    If you abstract both systems to their essence, the difference can be captured in a single sentence: orchestration-driven systems are fundamentally about “humans managing AI,” while model-native systems are fundamentally about “AI managing itself.”

    • The orchestration-driven approach hands all control back to the developer. You can precisely control its behavior at every step, and the system behaves more like a finely calibrated instrument that can be tuned incrementally.
    • The model-native approach grants more decision-making power to the model itself. You simply provide the final goal, and it plans the path, chooses actions, verifies results, and iteratively corrects on its own.

    Grasping this point captures the main thread behind every technical difference that follows.

    Architecture Comparison: Built-In Capability vs. External Orchestration

    Model-Native Approach: Giving the Brain Hands and Feet

    The core idea of the model-native approach is to build the capabilities an agent needs directly into the large model itself. You can picture it this way: the model vendor integrates a set of hands (for calling tools) and feet (for executing actions) directly onto the “brain,” and the model decides for itself when to think, when to reach out, and when to take a step. The entire system consists of “one decision-making hub plus a set of fixed tools,” with no independent external scheduler.

    The biggest advantage of this design is a short decision chain and continuous context. Because planning, decision-making, and execution all happen within a single model inference process, information is not repeatedly serialized and passed between multiple systems. In theory, this means faster responses and stronger intent consistency. The tradeoff is that the granularity of control is bounded by the model’s own capabilities, making it difficult for developers to precisely intervene at intermediate stages or enforce constraints on any given step.

    External Orchestration Approach: Giving the Brain a Project Manager

    The orchestration-driven approach treats the large model merely as a “code generator” and wraps it in an independent, usually open-source, control and scheduling system. This framework layer acts like a dedicated project manager: it tells the model when to analyze, when to act, and how to roll back and retry when it makes mistakes—while the model itself does not hold decision-making authority over the workflow.

    The value of this design lies in controllability and auditability. Because the workflow logic is externalized and transparent, developers can read, modify, and extend the scheduling strategy, precisely controlling the trigger conditions and execution boundaries of each step. The cost is a longer chain, since repeated interactions between the model and the framework introduce context-management overhead.

    The following pseudocode illustrates the control nature of “external orchestration”:

    1. # Skeleton of a flow driven by an external scheduler (illustrative)
    2. def run(task):
    3. plan = plan_agent.read_and_plan(task) # Read-only: produce the plan
    4. for step in plan.steps:
    5. if user.intervene(): # The user can interrupt at any time
    6. step = user.revise(step)
    7. result = build_agent.execute(step) # Execute: modify code / run tests
    8. if not verify(result):
    9. plan = plan_agent.revise(result) # Fall back and re-plan on failure
    10. return result

    The Core Engineering Pattern: Enforced Separation of Two Main Agents

    The most representative innovation of the orchestration-driven approach is the enforced decoupling of “thinking” from “doing”—splitting planning and execution into two independent agents with mutually exclusive permissions and single responsibilities, exchanging information through the file system.

    The Read-Only Planning Agent

    The planning agent has read-only permission and is responsible solely for reading code, organizing context, and designing the plan and architecture. Its key constraint is that it is absolutely forbidden from modifying any files. This constraint may seem strict, but it is in fact the core of quality assurance—it mechanically eliminates the problem of “plan drift caused by editing while thinking,” ensuring that the output is a fully considered, traceable design document rather than operations polluted by momentary impulses.

    The Executable Build Agent

    The build agent, by contrast, has only execution permission. It is responsible for modifying code, running tests, and fixing problems strictly according to the plan produced by the planning agent, but it cannot change the plan on its own. Want to change the plan? You must go back to the planning stage.

    This design of “physically isolating read and write permissions” delivers three benefits:

    1. Lower risk of errors: The executor cannot improvise, greatly reducing the possibility of out-of-bounds damage.
    2. Stronger auditability: With planning and execution separated, the rationale for “why we did it this way” at every step can be found in the read-only artifacts.
    3. Support for human-in-the-loop intervention: The two agents exchange information through the file system as a “shared blackboard,” and developers can interrupt, review, or modify the plan at any point before releasing execution.

    Lightweight Sub-Agents: On-Demand Offloading

    Building on the dual-agent foundation, mature orchestration-driven systems typically also introduce lightweight sub-agents to handle parallelizable, independent subtasks (such as retrieving a specific module, generating unit tests, or summarizing a change list). They do not carry main-workflow decisions; they are simply dispatched as “temporary workers” by the main agents on demand, thereby improving throughput without increasing the complexity of the main chain.

    Control Philosophy Comparison: Precise Control vs. Goal-Oriented

    Placing the two approaches side by side reveals two distinctly different control philosophies:

    Dimension Orchestration-driven (humans manage AI) Model-native (AI autonomous)
    Decision-making body External scheduler The model itself
    Control granularity Fine; step-by-step intervention Coarse; goal-level units
    Auditability High (externalized, transparent flow) Lower (decisions implicit in inference)
    Context continuity Requires cross-system transfer Naturally continuous
    Suitable tasks Complex, high-risk, requiring strong constraints Clear, well-bounded, efficiency-focused

    Selection Guidance: No Best Option, Only the Most Suitable

    The two approaches are not a matter of superior versus inferior, but of fitting different scenarios:

    • If the task involves changes to a core code path, extremely high correctness requirements, and the need for strict auditing and human oversight, the orchestration-driven dual-agent model is the safer choice. The strong control of “humans managing AI” significantly reduces the cost of rework and incidents.
    • If the task is routine development with clear goals, well-defined boundaries, and a focus on iteration speed, the model-native approach’s short chain and high continuity will be more efficient.

    Key Engineering Practices

    Regardless of which approach you choose, implementation should attend to the following universal best practices:

    1. Least privilege: Read-only and execution permissions must be isolated, avoiding “editing while thinking.”
    2. Human-in-the-loop: Preserve an entry point to interrupt, review, and correct at any time, keeping the AI in a supervisable position.
    3. Verification loop: Any execution result must pass an independent check (such as automated testing) before deciding whether to proceed or roll back.
    4. Persistent context: Use files or structured artifacts to record plans and decisions, which supports both auditing and recovery after a task is interrupted.
    5. Moderate parallelism for subtasks: Use lightweight sub-agents to offload independent subtasks, but avoid letting them intervene in main-workflow decisions.

    Conclusion

    The two architectural approaches to AI coding agents are, at their core, two answers to the question of “where control lives.” Understanding the distinction between “built-in capability” and “external orchestration,” and mastering transferable engineering patterns such as “separating read from write, isolating permissions, collaborating through files, and keeping humans in the loop,” is more valuable than memorizing the shape of any single system—because the patterns themselves are the true foundation for building the next generation of reliable AI-assisted development systems.