Logo

The Two Paths of Agentic Design: Intent-Based vs. Process-Based Architectures

The explosion of AI coding tools, from Cursor and Windsurf to Claude Code and specialized infrastructure agents, has given us a rare glimpse into the "source code" of cognition. By analyzing the system prompts that power these tools, a clear bifurcation in design philosophy has emerged.

We are not just seeing "better prompts"; we are seeing two distinct architectural patterns: Intent-Based Generalists and Process-Based Specialists.

1. The Intent-Based Generalist

Examples: Cursor, Windsurf (Cascade), Claude Code

The Generalist architecture is optimized for velocity and flexibility. Its core philosophy is "Solve the user's problem by any means necessary."

Characteristics

  • Permissive Tooling: These agents are often given raw shell access and broad file system permissions. They are trusted to use tools like grep, find, and sed responsibly.
  • Loose State Management: Progress is tracked implicitly through the conversation history or simple "memory banks."
  • Outcome-Oriented Instructions: The prompt focuses on the what, not the how.
    • Instruction: "You are an agent - please keep going until the user's query is completely resolved."
    • Instruction: "Autonomously resolve the query to the best of your ability."

The "Loop" Pattern

Generalist prompts often encode a simple cognitive loop:

  1. Explore: "Use tools to gather information."
  2. Act: "Make code changes."
  3. Verify: "Run terminal commands to execute the code."

There are no hard gates. If the agent decides to skip verification because the task looked simple, it can. This allows for the "magic" feeling where a tool instantly fixes a bug, but it also leaves room for regression loops where the agent tries the same failed fix three times.

2. The Process-Based Specialist

Example: Google Antigravity

The Specialist architecture is optimized for safety, correctness, and complex multi-step reasoning. Its core philosophy is "Follow the protocol to ensure the result is valid."

Characteristics

  • Strict Modes: The agent operates in distinct states (e.g, PLANNING, EXECUTION, VERIFICATION). It cannot write code while in PLANNING mode.
  • Mandatory Artifacts: The agent is required to maintain living documents that exist outside the chat context.
    • Requirement: "Always create implementation_plan.md and get user approval."
    • Requirement: "Create walkthrough.md to show proof of work."
  • Gated Transitions: The agent is physically strictly forbidden from moving to the next step until specific criteria are met.
    • Constraint: "Do not proceed to EXECUTION if planning is not approved."
    • Constraint: "Stop immediately after writing code. Run validation tools. ONLY after validation passes can you mark the TODO complete."

The "State Machine" Pattern

Unlike the loose loop of the Generalist, the Specialist operates as a Finite State Machine:

graph LR
    A[Start] --> B(Planning Mode)
    B --> C{User Approved?}
    C -- No --> B
    C -- Yes --> D(Execution Mode)
    D --> E(Verification Mode)
    E --> F{Tests Pass?}
    F -- No --> D
    F -- Yes --> G[Finish]

This drastically reduces hallucinations and "lazy" coding, but at the cost of speed. It feels more like working with a senior engineer who insists on writing a design doc first.

Key Divergences

1. Shell Access vs. Typed APIs

Generalists often treat the shell as a universal adapter. They run npm install, git status, and python script.py directly. Specialists differ. Some, like infrastructure agents, deprecate raw shell usage entirely in favor of typed APIs (e.g, list_resources instead of kubectl get pods) or wrap shell commands in strict "read-only" vs. "mutation" safety checks.

2. Implicit vs. Explicit Context

Generalists rely on the context window. "Look in chat history for your current working directory." Specialists rely on external state. "Update task.md... Synthesize progress from task.md." This allows them to tackle tasks that exceed the context window by offloading state to the file system.

Conclusion: Which Architecture to Use?

If you are building an AI agent, the choice depends on your error tolerance:

  • Build a Generalist if you want a "Coding Buddy." The goal is friction reduction. The user is in the loop, acting as the final reviewer. Occasional errors are acceptable prices for speed.
  • Build a Specialist if you want an "Autonomous Engineer." The goal is delegation. The user wants to fire-and-forget a complex task (e.g, "Refactor this entire module" or "Migrate our database").

The future isn't one or the other. We will likely see Hybrid Architectures, where a Generalist interface (for chat) spawns ephemeral Specialist sub-agents to handle complex sub-tasks, combining the speed of intent-based prompting with the rigor of process-based state machines.