The agentic maturity roadmap
The shift to agentic architecture isn't an all-or-nothing jump. Both AWS and Microsoft define a progression of AI maturity—from simple assistants to complex, autonomous swarms.
AI Agency Maturity Levels
| Level | Type | Autonomy | Example |
|---|---|---|---|
| Level 1 | Copilot | Assistive (Human-led) | Chatbot answering questions from a manual |
| Level 2 | Managed Agent | Conditional (Tool-use) | Agent searching a DB and updating a record |
| Level 3 | Multi-Agent | Collaborative (Handoffs) | A router agent delegating to a coding agent |
| Level 4 | Autonomous Swarm | Self-Directed (Goal-based) | SOMA/MOMA swarms executing long-running projects |
Newbie Tip: Agency vs. Assistance
Think of a Copilot as a helpful passenger giving you directions. An Agent is like an Uber driver: you give them a destination (goal), and they decide the route, handle the traffic (tools), and get you there. A Swarm is like an entire logistics company coordinating a fleet to deliver a complex project.
The agentic shift: from prompts to autonomous systems
The transition from traditional software and one-shot generative AI to agentic systems represents a fundamental paradigm shift in computing. Traditional software follows deterministic logic paths. GenAI assistants respond to prompts with generated text. Agentic systems do something fundamentally different: they maintain persistent state, reason about goals, plan multi-step sequences, and execute actions through tools—all while operating within bounded autonomy and governance frameworks.
This shift moves beyond merely generating content to autonomously pursuing objectives. Where a chatbot might answer a question, an agentic system can break down that question into subtasks, retrieve information from multiple sources, reason about the best approach, execute API calls to external systems, observe the results, and iterate—all within a defined workflow with explicit approval boundaries. The key is not just intelligence, but agency: the capacity to take purposeful action in pursuit of goals.
Traditional Software vs GenAI Assistant vs Agentic System
| Dimension | Traditional Software | GenAI Assistant | Agentic System |
|---|---|---|---|
| Behavior | Deterministic execution of predefined logic paths | Generates responses to prompts, no persistent goals | Autonomous planning and action toward defined objectives |
| State | Transient request/response or database transaction | Limited conversation history, no workflow state | Persistent workflow state with memory and context tracking |
| Tool use | Direct API calls through hardcoded integration points | No tool use (only text generation) | Dynamic tool selection and composition during execution |
| Failure mode | Exception handling and error codes | Incorrect or hallucinated content | Non-deterministic outcomes requiring guardrails and oversight |
Enterprise agentic reasoning loop
Loading diagram...
Memory and state management patterns
Modern agentic architectures distinguish between three types of memory: Short-term memory (the immediate context window, often requiring summarization or "compaction" to stay within token limits), Long-term memory (indexable vector stores or durable databases for historical recall), and Working state (the current "Task Ledger" or plan progress maintained during complex workflows). Techniques like Sliding Windows and Message Compression are essential for managing long-running conversations without context overflow.
Unlike traditional software that follows deterministic "if-then" logic, agentic systems operate on probabilistic reasoning. This means the system doesn't just follow a path—it evaluates the likelihood of a path succeeding based on its internal weights and external observations. This shift requires architects to move from binary pass/fail unit tests to statistical evaluation frameworks that measure alignment, accuracy, and safety across many runs.
Standardization through protocols like the Model Context Protocol (MCP) is becoming a critical architectural concern. MCP allows agents to discover and interact with tools across different environments without custom integration code for every backend, effectively serving as the "USB port" for AI agents.
Why architecture matters before choosing tools
Premature tool selection is a leading cause of brittle agentic systems. When organizations start with "we want to use [specific framework]" rather than "we need to solve [problem type]", they often end up with architectures constrained by tool limitations rather than designed for enterprise needs. Architecture-first thinking ensures patterns, governance, integration, and scalability drive design decisions—then tools are selected to support those patterns.
Consider the parallel to object-oriented programming in the 1990s. Organizations that started with "we need design patterns" built maintainable systems that could be implemented in any OO language. Those that started with "we need Java" often ended up with solutions shaped by Java-specific constraints rather than fundamental design principles. The same pattern plays out today with agentic frameworks: start with architecture, not tools.
Core architectural principles for agentic systems
| Principle | Definition | Enterprise impact |
|---|---|---|
| Separation of concerns | Perception, reasoning, memory, and action are distinct components with clear interfaces | Independent development, testing, and scaling of each capability |
| Bounded autonomy | Agents operate within explicit action boundaries and approval gates | Governable deployment with clear accountability and risk controls |
| Composability | Agents and tools can be combined like building blocks to create new capabilities | Reusable patterns that accelerate development and reduce duplication |
Design patterns are to agentic development what design patterns were to object-oriented programming: reusable solutions to common problems that have emerged from real-world experience. Router patterns, ReAct loops, plan-and-execute, fan-out/fan-in, and human-in-the-loop patterns provide tested blueprints for common agent behaviors. Rather than inventing custom approaches for each project, enterprises should establish pattern libraries that capture proven designs along with their trade-offs and implementation guidance.
Enterprise Agentic Architecture
Salesforce Architect guide on principles and patterns for building enterprise-grade agentic systems with clear separation of concerns, bounded autonomy, and composability.
Read the architecture guideAvoid framework-driven architecture
Starting with "we need LangChain" or "we need Bedrock Agents" often leads to designs shaped by framework capabilities rather than business needs. Begin with problem decomposition, governance requirements, and integration patterns—then evaluate frameworks based on how well they support your architectural requirements.
Core agent components
Every agentic system, regardless of implementation framework, consists of core architectural components: Model, Tools, Orchestration, Memory, and System Context. Understanding these components as separate architectural concerns enables independent development, testing, and optimization. The pattern is analogous to the Model-View-Controller pattern in web applications: clear separation enables specialized expertise and parallel development.
Agent component mindmap
Loading diagram...
Component purposes and design concerns
| Component | Purpose | Key design concerns |
|---|---|---|
| Perception | Interpret user inputs and environmental context to build understanding | Input validation, intent classification, context extraction, security filtering |
| Planner/Reasoner | Translate goals into actionable plans and make decisions during execution | Planning algorithms, reasoning quality, tool selection, constraint handling |
| Memory | Maintain state across reasoning cycles and persist knowledge for reuse | State consistency, retrieval relevance, storage efficiency, privacy controls |
| Action Executor | Invoke tools and APIs safely with proper error handling and monitoring | Rate limiting, timeout handling, retry logic, audit logging |
| Tools | Encapsulate business logic and external system access in reusable interfaces | API design, error propagation, input validation, output formatting |
The power of this component model lies in its independence: you can upgrade your reasoning engine without changing your tool layer, or swap storage backends for memory without affecting planning logic. This modularity is essential for enterprise systems that must evolve over years, not months. It also enables specialization: ML engineers optimize the reasoner, security teams harden the action executor, and domain experts develop domain-specific tools—all working in parallel.
The Agentic Enterprise — The IT Architecture for the AI-Powered Future
Salesforce Architect guide on the 11-layer IT reference architecture for deploying AI agents at scale, covering the Agentic Layer, Semantic Layer, AI/ML Layer, and Enterprise Orchestration Layer.
Read the full IT architecture guideKnowledge Check
Test your understanding with this quiz. You need to answer all questions correctly to mark this section as complete.