Agent Architecture & Design: NCP-AAI Domain 1 (15%)

What this domain covers

Agent Architecture and Design is about how you structure an agentic system before you write the prompts: how many agents, how they coordinate, where control flow lives, and how information moves between components. It is 15% of the exam — tied for the largest domain — because architecture decisions constrain everything downstream.

The core agent loop

Every agent, however complex, runs a perceive → reason → act → observe loop. The model receives context, decides on an action (often a tool call), the action executes, the result is fed back, and the loop repeats until a stopping condition. Understanding this loop is the foundation for every architecture choice above it.

# Minimal single-agent loop (pseudocode)
state = init(goal)
while not state.done and state.steps < MAX_STEPS:
    thought = llm.plan(state)          # reason
    action  = thought.tool_call        # decide
    result  = tools.run(action)        # act
    state   = state.update(result)     # observe
return state.answer

Single-agent vs multi-agent

Single-agent designs are simpler to build, debug, and evaluate — prefer them until a task genuinely needs specialization. Multi-agent designs split work across specialized agents (e.g. a planner, a researcher, a coder, a critic) and shine when sub-tasks need different tools, prompts, or models. The cost is coordination overhead and harder debugging.

Common multi-agent topologies

You should recognize the standard coordination patterns and when each fits: orchestrator–worker (a supervisor delegates to specialists and merges results), sequential pipeline (each agent's output feeds the next), and reflection/critic (one agent produces, another critiques and revises). Hierarchical designs nest these.

Orchestrator–worker:  supervisor → [researcher, coder, writer] → merge
Sequential pipeline:  intake → enrich → decide → respond
Reflection/critic:    generator ⇄ critic (loop until good enough)

Design trade-offs the exam expects

Architecture questions usually ask you to weigh autonomy against control, cost against capability, and latency against thoroughness. More autonomous agents handle open-ended tasks but are harder to keep safe and predictable; tightly scripted workflows are reliable but brittle. The right answer is almost always "match the architecture to the task's variability and risk."

Exam tip

When a question offers a multi-agent design and a simpler single-agent or workflow design that both solve the task, the simpler one is usually correct. Examifyr-style readiness questions — and the real exam — reward matching architecture to need, not maximizing agent count.