CCA Agentic Architecture Domain Guide: Master the Highest-Weighted Section in 2026

Short Answer

Domain 1 (Agentic Architecture & Orchestration) represents 27% of the 2026 CCA exam with 16 questions covering augmented LLMs, workflow patterns (prompt chaining, routing, parallelization), agent architecture, hub-and-spoke orchestration, and MCP integration. Master the workflows vs. agents distinction and five orchestration patterns to pass this highest-weighted domain.

Understanding Domain 1: The Foundation of Modern AI Systems

The Claude Certified Architect – Foundations certification launched in March 2026 with Domain 1 carrying the highest weight at 27% of the 60-question exam. This domain tests your ability to design production-ready agentic systems using Claude's advanced capabilities including augmented LLMs, workflow orchestration, and multi-agent coordination.

Domain 1 focuses on practical architecture decisions rather than theoretical concepts. You'll encounter scenario-based questions testing your ability to choose between workflows and agents, design appropriate orchestration patterns, and integrate tools through the Model Context Protocol (MCP). The exam assumes 6+ months of hands-on experience building agentic systems in production environments.

The domain covers five critical areas: augmented LLM fundamentals, workflow vs. agent architecture decisions, orchestration patterns (hub-and-spoke, sequential, parallel), error handling strategies, and balancing autonomy with safety constraints. Each area directly relates to real-world challenges faced when deploying Claude-powered systems at scale.

The Augmented LLM: Building Blocks of Agentic Systems

The augmented LLM serves as the foundational component for all agentic architectures tested in Domain 1. Unlike base language models, augmented LLMs possess three enhanced capabilities that enable autonomous operation: retrieval, tool integration, and memory management.

Crucially, an augmented LLM becomes an agent only when placed in an autonomous loop with environmental feedback. The augmentation capabilities alone do not constitute agency – they are building blocks from which both workflows and agents are constructed.

Workflows vs. Agents: The Critical Architecture Decision

This distinction represents the most heavily tested concept in Domain 1. The CCA exam emphasizes when to choose each approach based on specific architectural requirements and constraints.

Workflows: Deterministic Orchestration

Workflow characteristics include:

• Controlled token usage through predetermined call sequences
• Predictable debugging via fixed execution paths
• Consistent quality through repeatable processes
• Lower latency for simple, well-understood tasks
• Easy monitoring with predefined checkpoints

Agents: Autonomous Decision Making

Agent characteristics include:

• Dynamic adaptation to changing task requirements
• Self-correction through feedback loops
• Open-ended problem solving without predetermined steps
• Higher token usage due to exploratory behavior
• Complex debugging through dynamic execution paths

Decision Framework

Anthropic's official guidance recommends starting with simple LLM optimization, adding retrieval when needed, implementing workflows only when demonstrably necessary, and graduating to agents exclusively for genuinely open-ended problems.

The Five Essential Workflow Patterns

Domain 1 tests your knowledge of five orchestration patterns that form the foundation of production workflow systems. Each pattern addresses specific architectural challenges and use cases.

Pattern 1: Prompt Chaining

typescriptasync function promptChain(input: string) {
  // Step 1: Generate outline
  const outline = await claude.messages.create({
    model: "claude-3-5-sonnet-20241022",
    max_tokens: 1000,
    messages: [{
      role: "user", 
      content: `Generate an outline for: ${input}`
    }]
  });
  
  // Gate: Validate outline structure
  if (!validateOutline(outline.content[0].text)) {
    throw new Error("Outline validation failed");
  }
  
  // Step 2: Write content
  const content = await claude.messages.create({
    model: "claude-3-5-sonnet-20241022",
    max_tokens: 4000,
    messages: [{
      role: "user",
      content: `Write content based on this outline: ${outline.content[0].text}`
    }]
  });
  
  return content.content[0].text;
}

Use prompt chaining when tasks decompose into sequential subtasks, each step builds on the previous one, and you need verification checkpoints between operations.

Pattern 2: Routing

Routing uses an initial classification step to direct inputs to specialized downstream processes. Each handler is optimized for its specific category, improving both quality and efficiency.

Pattern 3: Parallelization

Parallelization runs multiple LLM calls simultaneously with programmatic result aggregation. Two variants exist: sectioning (independent subtasks) and voting (redundant execution for confidence).

Pattern 4: Orchestrator-Workers

This pattern uses a central LLM to dynamically decompose tasks, delegate subtasks to specialized workers, and synthesize results. Unlike parallelization, the orchestrator determines subtasks dynamically rather than through predetermined code logic.

Pattern 5: Evaluator-Optimizer

Implements iterative refinement loops where one LLM generates output while another evaluates and provides feedback. The generator refines until the evaluator is satisfied or maximum iterations are reached.

Hub-and-Spoke Orchestration Architecture

The hub-and-spoke pattern represents the recommended architecture for multi-agent systems in production environments. This pattern addresses token economy optimization and prevents the context leakage common in naive multi-agent implementations.

Architecture Components

The hub serves as a central coordinator that receives tasks, determines appropriate delegation strategies, routes work to specialized spokes, and synthesizes results. Spokes operate as focused agents with specific capabilities and limited scope.

pythonclass HubOrchestrator:
    def __init__(self):
        self.spokes = {
            'research': ResearchAgent(),
            'analysis': AnalysisAgent(), 
            'writing': WritingAgent()
        }
    
    async def process_task(self, task: str):
        # Hub determines delegation strategy
        plan = await self.create_execution_plan(task)
        
        results = {}
        for step in plan.steps:
            spoke = self.spokes[step.agent_type]
            result = await spoke.execute(step.subtask, results)
            results[step.id] = result
        
        # Hub synthesizes final output
        return await self.synthesize_results(results, task)

Token Optimization Benefits

Hub-and-spoke architecture prevents the exponential token growth common in mesh-connected multi-agent systems. Each spoke maintains only task-relevant context rather than full conversation history, reducing token costs by 60-80% compared to naive implementations.

The hub maintains global context while spokes operate with focused, pruned context windows. This separation enables efficient scaling to dozens of specialized agents without prohibitive token costs.

Failure Isolation and Recovery

Spoke failures remain isolated and recoverable through hub coordination. When a spoke fails, the hub can retry with different parameters, delegate to alternative spokes, or adjust the overall execution strategy without cascading failures.

MCP Integration and Tool Design

The Model Context Protocol (MCP) provides standardized integration between Claude and external tools, resources, and prompts. Domain 1 tests your ability to design MCP servers and clients that enable reliable tool usage in production systems.

MCP Architecture Components

json{
  "tools": [{
    "name": "search_codebase",
    "description": "Search code repository for specific patterns, functions, or files. Use for finding existing implementations before writing new code.",
    "input_schema": {
      "type": "object",
      "properties": {
        "query": {
          "type": "string", 
          "description": "Search query (function names, patterns, or file paths)"
        },
        "file_types": {
          "type": "array",
          "items": {"type": "string"},
          "description": "File extensions to include (e.g., ['.py', '.ts'])"
        }
      },
      "required": ["query"]
    }
  }]
}

Resource Management

Error Handling and Reliability Patterns

Production agentic systems require robust error handling strategies that maintain system reliability while preserving user experience. Domain 1 emphasizes practical error recovery patterns over theoretical approaches.

Circuit Breaker Pattern

Implement circuit breakers around external tool calls to prevent cascade failures. When error rates exceed thresholds, the circuit breaker opens and routes requests to fallback handlers or cached responses.

Retry Strategies

Graceful Degradation

Design systems to provide partial functionality when components fail. For example, a research agent might return cached results when live search fails, or a coding agent might suggest manual steps when automated fixes fail.

Monitoring and Observability

Implement structured logging for agentic loops, tool calls, and decision points. Track token usage, latency, error rates, and success metrics across different execution paths.

Balancing Autonomy and Safety

Domain 1 tests your ability to design systems that maximize agent autonomy while maintaining safety boundaries and user control. This balance requires careful consideration of risk tolerance and failure modes.

Autonomy Levels

Safety Constraints

Implement capability boundaries that prevent agents from accessing dangerous tools or performing irreversible actions. Use resource limits to prevent runaway token usage or infinite loops.

Risk Assessment Framework

Production Deployment Considerations

Domain 1 includes questions about deploying agentic systems in production environments, focusing on scalability, cost optimization, and operational excellence.

Scaling Strategies

Cost Optimization

Operational Excellence

Study Strategy for Domain 1 Success

Given Domain 1's 27% weight, allocate proportional study time to master these concepts. Focus on practical scenarios rather than memorizing definitions, as the exam emphasizes architecture decisions over recall.

Priority Topics

Practice Scenarios

Work through architecture decisions for realistic scenarios like customer support automation, code review systems, and research assistants. Focus on justifying your choices based on requirements, constraints, and trade-offs.

The Complete CCA Exam Guide 2026 provides additional practice questions and scenarios specific to Domain 1. Consider combining this with the CCA Claude Code Configuration Domain Guide for comprehensive coverage of the exam's highest-weighted domains.

FAQ

Domain 1 (Agentic Architecture & Orchestration) covers 27% of the 60-question CCA exam, making it the highest-weighted domain with approximately 16 questions. This represents more than one-quarter of your total score, making it the most critical domain to master.

Workflows use predefined code paths where application logic controls the flow of LLM calls, while agents employ agentic loops where Claude dynamically directs its own processes. Workflows are deterministic and predictable, while agents are autonomous and adaptive to changing conditions.

Hub-and-spoke orchestration uses a central coordinator (hub) to route tasks to specialized agents (spokes), optimizing token usage and preventing context leakage. This pattern reduces token costs by 60-80% compared to mesh-connected multi-agent systems while providing failure isolation and recovery capabilities.

The Model Context Protocol (MCP) provides standardized integration between Claude and external tools, resources, and prompts through Python or TypeScript transports. MCP servers expose capabilities while clients connect to servers, enabling reliable tool usage in production systems with clear interfaces and error handling.

The five patterns are prompt chaining (sequential steps with gates), routing (classification-based delegation), parallelization (simultaneous execution), orchestrator-workers (dynamic task decomposition), and evaluator-optimizer (iterative refinement loops). Each pattern addresses specific architectural challenges and use cases.

Choose agents for open-ended problems with unpredictable requirements, unknown subtask counts, and situations requiring dynamic adaptation. Use workflows for well-defined tasks with sequential steps, controlled token usage requirements, and need for predictable debugging and consistent quality.

Essential patterns include circuit breakers around external tool calls, exponential backoff with jitter for retries, selective retry based on error types, graceful degradation for partial functionality, and comprehensive monitoring with structured logging for observability and debugging.

Balance autonomy and safety through three levels: human-in-the-loop (explicit approval), human-on-the-loop (monitoring with intervention), and human-out-of-the-loop (full autonomy with boundaries). Implement capability boundaries, resource limits, approval gates, and rollback mechanisms based on risk assessment.

Key considerations include horizontal and vertical scaling strategies, cost optimization through prompt caching and batch APIs, operational excellence with deployment pipelines and A/B testing, performance monitoring with key metrics tracking, and robust alert systems for anomaly detection.

Allocate 27% of your study time to Domain 1 given its weight. Prioritize workflows vs. agents decisions, hub-and-spoke orchestration, MCP integration, error handling patterns, and safety vs. autonomy balance. Focus on practical scenarios and architecture justification rather than memorizing definitions, as the exam emphasizes real-world decision-making.