Agentic Architecture Fundamentals

Domain 1: Agentic Architecture (27% of Exam)

This is the largest domain on the CCA exam. Nearly one-third of all questions test your ability to design, debug, and reason about agentic systems. If you master this domain, you've secured your foundation for passing.

The exam doesn't test trivia. It tests architectural judgment. You'll be dropped into production scenarios and asked: "What's the right design decision here?"

What "Agentic" Means (Precisely)

An agentic system is an AI system that can:

1. Perceive its environment (read files, query APIs, observe state)
2. Plan a sequence of actions toward a goal
3. Act on the environment (write files, call tools, send messages)
4. Reflect on the results and adjust

This is different from a chatbot (responds to prompts) or an assistant (follows single instructions). An agent operates in a loop — perceive, plan, act, reflect — until the goal is achieved or a stopping condition is met.

The Three Levels of AI Autonomy

Level 1: ASSISTIVE
  Human provides instruction → AI responds → Human reviews
  Example: "Summarize this document" → summary → done
  Control: Human in the loop at every step

Level 2: AGENTIC
  Human provides goal → AI plans + executes multi-step → Human reviews result
  Example: "Fix this bug" → AI reads code, identifies issue, writes fix, runs tests → done
  Control: Human reviews at boundaries (start + end)

Level 3: AUTONOMOUS
  Human provides objective → AI operates indefinitely toward objective
  Example: "Keep the system healthy" → AI monitors, patches, deploys, alerts
  Control: Human sets guardrails, AI operates within them

CCA exam focus: Level 2 (Agentic) — multi-step execution with tool use.

Core Components of Agentic Architecture

Every agentic system has four components. The exam tests your ability to design each one correctly.

1. Perception Layer

How the agent observes its environment:

• Tool results — API responses, file contents, database queries
• Context — conversation history, system state, user preferences
• Feedback — error messages, test results, validation output

# Perception in Claude: tool results inform the next action
tools = [
    {"name": "read_file", "description": "Read a file from the filesystem"},
    {"name": "run_tests", "description": "Execute test suite and return results"},
    {"name": "search_code", "description": "Search codebase for patterns"},
]
# Agent perceives via tool results → plans next action

2. Planning Layer

How the agent decides what to do:

• Goal decomposition — breaking complex objectives into steps
• Tool selection — choosing the right tool for each step
• Dependency ordering — parallel vs sequential execution

# Planning in Claude: the model reasons about next steps
system_prompt = """
You are a code review agent. When given a PR:
1. Read the changed files (use read_file)
2. Check for security issues (use search_code for patterns)
3. Run the test suite (use run_tests)
4. Summarize findings

Execute steps in order. If tests fail, investigate before summarizing.
"""

3. Action Layer

How the agent changes its environment:

• Tool use — calling MCP tools, APIs, file operations
• Output generation — writing code, creating documents, sending messages
• Side effects — database writes, deployments, notifications

4. Memory Layer

How the agent maintains state across interactions:

• Working memory — current conversation context window
• Episodic memory — records of past actions and outcomes
• Semantic memory — knowledge base (vector search, brain entries)
• Procedural memory — learned skills and patterns

Exam Scenario Pattern

Here's how the CCA exam tests this domain:

The exam rewards appropriate complexity. Don't over-engineer. Don't under-engineer. Match the architecture to the problem.

What You'll Build in This Module

Over the next 4 lessons in this module, you'll learn:

• Lesson 2: How to design agentic loops that don't break (stopping conditions, error recovery, infinite loop prevention)
• Lesson 3: Multi-agent topologies (when to use parallel agents, supervisor patterns, and message passing)
• Lesson 4: Session management and state persistence (how to maintain context across tool calls)
• Lesson 5: Practice scenarios for Domain 1 (exam-style questions with explanations)

Key Takeaways for the Exam

1. Agentic ≠ autonomous. The exam tests Level 2 (goal + multi-step), not Level 3 (indefinite operation).
2. Four components: Perceive, plan, act, reflect. Know which layer each architectural decision affects.
3. Match complexity to problem. Simple problems get simple architectures. Only use multi-agent when single-agent isn't sufficient.
4. Memory is external. Claude's context window is working memory. Everything else requires tools (CLAUDE.md, MCP, vector DB).
5. Guardrails matter. Every agentic system needs explicit stopping conditions, error handling, and safety boundaries.