diff --git a/agentic-knowledge/POWER.md b/agentic-knowledge/POWER.md
new file mode 100644
index 0000000..66cec66
--- /dev/null
+++ b/agentic-knowledge/POWER.md
@@ -0,0 +1,330 @@
+---
+name: "agentic-knowledge"
+displayName: "Agentic Knowledge"
+description: "Dynamic architectural guidance for building agentic AI systems using current AWS prescriptive guidance and patterns"
+keywords: ["agentic ai",  "agentic architecture", "agent patterns", "agentic workflows", "aws architecture", "multi-agent systems",  "autonomous systems",  "intelligent agents", "prescriptive guidance", "architectural patterns"]
+author: "Robert Bradley"
+---
+
+# Agentic Knowledge Power
+
+This power provides dynamic architectural guidance for building agentic AI systems on AWS. Rather than static documentation, it leverages MCP servers to access current AWS prescriptive guidance and combines it with intelligent steering to provide contextual, up-to-date architectural recommendations.
+
+## MCP Servers:
+  - strands-agents
+  - agentcore-mcp-server
+  - aws-knowledge
+
+## Foundational Concepts
+
+### Definitions and Core Terminology
+
+**Agentic AI**: A paradigm of intelligent systems consisting of software agents capable of adaptive behavior, complex coordination, and delegated decision-making. These systems can perceive their environment, reason about goals, and take autonomous actions to achieve objectives.
+
+**Software Agents**: Autonomous digital entities that perceive their environment through sensors, reason about goals using internal models, and act through effectors to achieve desired outcomes. They exhibit characteristics of autonomy, reactivity, proactivity, and social ability.
+
+**Agent Patterns**: Reusable design templates that describe the structure and behavior of individual agents, including reasoning agents, tool-based agents, coding agents, and multi-agent collaborative patterns.
+
+**Agentic Workflows**: Complex orchestrations of multiple agents, tools, and environments that interact to form autonomous systems capable of handling sophisticated tasks through coordination, delegation, and collaborative problem-solving.
+
+### Evolution from Traditional Systems to Agentic Systems
+
+Traditional event-driven systems operate through reactive patterns where components respond to specific triggers and events. These systems follow predetermined workflows and require explicit programming for each scenario.
+
+Modern agentic systems represent a paradigm shift toward autonomous, goal-oriented behavior. Instead of following rigid event-response patterns, agentic systems can:
+- Perceive and interpret complex environments
+- Reason about goals and constraints
+- Plan and execute multi-step strategies
+- Adapt to changing conditions
+- Collaborate with other agents and humans
+
+This evolution enables systems that can handle ambiguous requirements, learn from experience, and operate effectively in dynamic environments.
+
+### Core Principles of Agentic Behavior
+
+#### 1. Autonomy
+Agents operate independently without constant human intervention, making decisions based on their goals, knowledge, and environmental conditions.
+
+#### 2. Reactivity
+Agents perceive their environment and respond appropriately to changes, maintaining awareness of their operational context.
+
+#### 3. Proactivity
+Agents take initiative to achieve their goals, planning ahead and anticipating future needs rather than merely reacting to events.
+
+#### 4. Social Ability
+Agents can interact and collaborate with other agents and humans through communication protocols and shared understanding.
+
+#### 5. Goal-Oriented Behavior
+Agents work toward specific objectives, making decisions that advance their goals while considering constraints and trade-offs.
+
+#### 6. Temporal Continuity
+Agents maintain persistent state and memory, learning from past experiences and maintaining context across interactions.
+
+### Characteristics of Effective Agentic Systems
+
+Effective agentic systems demonstrate three core capability dimensions:
+
+**Perception Capabilities**: The ability to sense, interpret, and understand environmental conditions, user inputs, and system states through various input modalities.
+
+**Reasoning Capabilities**: The capacity to process information, make decisions, plan actions, and solve problems using logical inference, pattern recognition, and learned knowledge.
+
+**Action Capabilities**: The power to execute decisions through tool usage, API calls, system modifications, and interactions with other agents or humans.
+
+## Business Value and Benefits
+
+### Accelerated Time to Value
+Agentic AI systems enable rapid deployment and faster decision-making through autonomous operation and intelligent automation. Organizations can achieve faster time-to-market for new capabilities and reduce the time required for complex decision-making processes.
+
+### Improved Customer Engagement
+Through personalized experiences and enhanced responsiveness, agentic systems can provide 24/7 availability, contextual understanding, and adaptive interactions that improve customer satisfaction and engagement metrics.
+
+### Reduced Operational Costs
+Automation benefits and efficiency gains from agentic systems reduce manual intervention requirements, optimize resource utilization, and streamline operational workflows, leading to significant cost reductions.
+
+### Innovation and Differentiation Benefits
+Agentic AI provides competitive advantages through organizational transformation, enabling new business models, enhanced service offerings, and innovative approaches to traditional challenges.
+
+### Modernization of Legacy Workflows
+Digital Transformation through Workflow Evolution allows organizations to modernize existing processes, integrate with modern systems, and adapt to changing business requirements more effectively.
+
+### Quantifiable Business Outcomes
+Organizations implementing agentic AI systems typically see measurable improvements in Operational Metrics, including reduced response times, increased throughput, improved accuracy rates, and enhanced customer satisfaction scores. Financial Impact includes cost savings from automation, revenue growth from improved services, and Strategic Benefits from competitive differentiation.
+
+## How This Power Works
+
+This power combines:
+- **AWS Prescriptive Guidance Priority**: Always starts with official AWS foundational documents on agentic AI
+- **Live Documentation Access**: Real-time retrieval of current guidance through MCP servers
+- **Grounded Recommendations**: All architectural advice is based on official AWS prescriptive guidance
+- **Modern Implementation**: Combines AWS best practices with current frameworks (Strands, AgentCore)
+
+## Core Capabilities
+
+### 🔍 **AWS Prescriptive Guidance Foundation**
+Always starts with official AWS prescriptive guidance documents:
+- **Foundations of agentic AI on AWS** - Core principles and architectural foundations
+- **Agentic AI patterns and workflows on AWS** - Specific implementation patterns
+- **Agentic AI frameworks, protocols, and tools on AWS** - Framework selection guidance
+- **Serverless and multi-tenant architectures** - Deployment and scaling strategies
+
+### 🏗️ **Architecture Design Assistance**
+Get contextual recommendations for:
+- **AWS Service Selection**: Compute (Lambda, ECS, EKS), Storage (S3, DynamoDB), Database (RDS, Aurora), Networking (VPC, API Gateway), Analytics (Kinesis, Glue)
+- **Strands Agent SDK implementation patterns**: Multi-agent coordination and framework integration
+- **AgentCore platform service selection and configuration**: Runtime, Memory, Gateway, and Observability services
+- **Multi-agent patterns**: A2A, Graph, Swarm, Workflow coordination patterns
+- **Memory and tool integration strategies**: Persistent context and tool ecosystem development
+- **Scalability considerations**: Auto-scaling, load balancing, performance optimization, and high availability design
+- **Security best practices**: Authentication, authorization, encryption, compliance, and access control patterns
+
+### 📋 **Implementation Guidance**
+Receive practical guidance on:
+- **Strands Agent SDK setup and configuration**: Getting started with multi-provider agent development
+- **AgentCore deployment and scaling strategies**: Serverless deployment, container orchestration, and performance tuning
+- **Memory integration and tool development**: Persistent context management and custom tool creation
+- **Observability and monitoring**: AgentCore platform monitoring, logging, and performance metrics
+- **Security implementation**: Authentication patterns, secure communication, and compliance frameworks
+- **Scalable architecture patterns**: Microservices deployment, event-driven architectures, and distributed systems design
+
+---
+
+*This power leverages MCP servers to ensure you always have access to the most current AWS prescriptive guidance and architectural patterns for agentic AI systems.*
+
+## Getting Started
+
+### 1. **Describe Your Use Case**
+Start by describing what you want to build:
+- "I need to build a customer service agent that can handle complex inquiries"
+- "I want to create a multi-agent system for data processing workflows"
+- "I need an agentic architecture for automated code review and deployment"
+
+### 2. **Get Grounded Recommendations**
+The power will:
+- **First search AWS prescriptive guidance** on agentic AI foundations and patterns
+- **Reference specific sections** from official AWS architectural guidance
+- **Identify appropriate patterns** based on prescriptive guidance recommendations
+- **Supplement with modern frameworks** (Strands, AgentCore) that align with AWS best practices
+
+### 3. **Refine Your Architecture**
+Through interactive dialogue and iterative refinement:
+- **Clarify requirements and constraints** through targeted questions
+- **Explore alternative architectural approaches** and evaluate trade-offs
+- **Address scalability, security, and operational concerns** with specific recommendations
+- **Iteratively improve and optimize** the architecture based on feedback
+- **Develop a concrete implementation roadmap** with step-by-step guidance
+
+## Modern Agentic Frameworks
+
+### Strands Agent SDK
+- **Multi-Provider Support**: Bedrock, Anthropic, OpenAI, Gemini, Llama models
+- **Agent Patterns**: Reasoning, tool-based, coding, and collaborative agents
+- **Multi-Agent Coordination**: A2A, Graph, Swarm, and Workflow patterns
+- **Tool Integration**: MCP tools, Python tools, and community ecosystem
+
+### AgentCore Platform
+- **AgentCore Runtime**: Serverless deployment and auto-scaling
+- **AgentCore Memory**: Event and semantic memory for persistent context
+- **AgentCore Gateway**: Transform APIs into agent-compatible tools
+- **AgentCore Observability**: Real-time monitoring and tracing
+
+### Integration Patterns
+- **Memory Integration**: Persistent context and learning capabilities
+- **Tool Ecosystem**: MCP protocol and custom tool development
+- **Multi-Agent Workflows**: Complex agent coordination and collaboration
+- **Deployment Strategies**: Serverless scaling and management
+
+## Example Interactions
+
+**"I need to build a customer service agent"**
+→ The power will first search AWS prescriptive guidance on "agentic AI patterns" and "customer service agents", reference specific architectural principles, then recommend Strands and AgentCore implementations that align with AWS best practices.
+
+**"How do I implement multi-agent collaboration?"**
+→ The power will search "agentic AI patterns and workflows" prescriptive guidance for multi-agent coordination principles, then provide implementation details using Strands multi-agent patterns (A2A, Graph, Swarm) and AgentCore services.
+
+**"What's the best architecture for agentic workflows?"**
+→ The power will reference AWS prescriptive guidance on "agentic workflows" and "serverless architectures", then recommend specific implementation approaches using modern frameworks that follow AWS architectural principles.
+
+## Troubleshooting
+
+### Common Issues and Solutions
+
+#### MCP Server Connection Issues
+**Problem**: MCP servers not responding or timing out
+**Solution**: 
+- Check your internet connection and AWS credentials
+- Verify MCP server configurations in mcp.json
+- Try restarting the MCP servers from the Kiro MCP panel
+- Check the MCP server logs for specific error messages
+
+#### Incomplete or Generic Responses
+**Problem**: Receiving generic advice instead of AWS-specific guidance
+**Solution**:
+- Be more specific in your architectural requirements
+- Mention specific AWS services or constraints you're working with
+- Ask follow-up questions to refine the recommendations
+- Request specific implementation examples or code snippets
+
+#### Framework Selection Confusion
+**Problem**: Unclear which framework (Strands vs AgentCore) to use
+**Solution**:
+- Strands Agent SDK: Use for multi-provider agent development and complex multi-agent patterns
+- AgentCore: Use for serverless deployment, memory management, and production scaling
+- Both can be used together: Strands for development, AgentCore for deployment
+
+#### Outdated Information
+**Problem**: Recommendations seem outdated or don't match current AWS services
+**Solution**:
+- The power uses live MCP servers to access current documentation
+- If information seems outdated, try rephrasing your question
+- Ask specifically for "current" or "latest" guidance
+- Report persistent issues to ensure MCP servers are functioning correctly
+
+### Getting Better Results
+
+#### Be Specific About Your Context
+- Mention your industry, use case, and scale requirements
+- Include any existing AWS services or constraints
+- Specify performance, security, or compliance requirements
+- Describe your team's technical expertise level
+
+#### Ask Progressive Questions
+- Start with high-level architecture questions
+- Drill down into specific implementation details
+- Ask about trade-offs between different approaches
+- Request specific examples or code snippets when needed
+
+#### Leverage Interactive Refinement
+- Respond to clarifying questions with detailed information
+- Ask for alternatives if the first recommendation doesn't fit
+- Request implementation roadmaps for complex architectures
+- Ask about operational considerations (monitoring, scaling, security)
+
+## Best Practices
+
+### Effective Usage Patterns
+
+#### 1. **Start with Requirements Gathering**
+- Clearly describe your business use case and technical requirements
+- Mention any existing AWS infrastructure or constraints
+- Specify performance, security, and compliance needs
+- Include information about expected scale and growth
+
+#### 2. **Follow the Guidance Hierarchy**
+- AWS Prescriptive Guidance provides the architectural foundation
+- Strands Agent SDK offers implementation flexibility and multi-agent patterns
+- AgentCore provides production-ready deployment and scaling
+- Use all three layers for comprehensive solutions
+
+#### 3. **Iterate and Refine**
+- Start with high-level architecture discussions
+- Progressively drill down into implementation details
+- Ask about trade-offs and alternative approaches
+- Request specific examples and code snippets
+
+#### 4. **Consider the Full Lifecycle**
+- Development: Use Strands for rapid prototyping and testing
+- Deployment: Leverage AgentCore for serverless scaling
+- Operations: Implement comprehensive monitoring and observability
+- Maintenance: Plan for updates and continuous improvement
+
+### Architecture Decision Guidelines
+
+#### When to Use Strands Agent SDK
+- ✅ Multi-provider model support needed
+- ✅ Complex multi-agent coordination required
+- ✅ Rapid prototyping and development
+- ✅ Custom tool integration needed
+- ✅ A2A, Graph, Swarm, or Workflow patterns
+
+#### When to Use AgentCore Platform
+- ✅ Production deployment and scaling
+- ✅ Serverless architecture preferred
+- ✅ Persistent memory and context needed
+- ✅ API transformation and gateway functionality
+- ✅ Enterprise security and compliance requirements
+
+#### When to Combine Both
+- ✅ Full development-to-production lifecycle
+- ✅ Complex multi-agent systems at scale
+- ✅ Need both flexibility and production reliability
+- ✅ Enterprise-grade agentic applications
+
+### Security and Compliance Best Practices
+
+#### Authentication and Authorization
+- Use AgentCore Identity for secure authentication
+- Implement proper access controls for agent interactions
+- Follow AWS IAM best practices for service permissions
+- Use VPC and security groups for network isolation
+
+#### Data Protection
+- Encrypt data in transit and at rest
+- Use AWS KMS for key management
+- Implement proper data retention policies
+- Follow compliance requirements (GDPR, HIPAA, etc.)
+
+#### Monitoring and Auditing
+- Implement comprehensive logging with AgentCore Observability
+- Monitor agent behavior and performance metrics
+- Set up alerts for anomalous behavior
+- Maintain audit trails for compliance
+
+### Performance Optimization
+
+#### Cost Management
+- Use appropriate model sizes for each task
+- Implement caching for frequently accessed data
+- Leverage AgentCore's pay-per-use pricing model
+- Monitor and optimize resource usage
+
+#### Scalability Planning
+- Design for horizontal scaling from the start
+- Use AgentCore Runtime for automatic scaling
+- Implement proper load balancing strategies
+- Plan for peak usage scenarios
+
+#### Latency Optimization
+- Choose models based on latency requirements
+- Implement efficient memory and context management
+- Use appropriate AWS regions for your users
+- Optimize tool and API integrations
\ No newline at end of file
diff --git a/agentic-knowledge/mcp.json b/agentic-knowledge/mcp.json
new file mode 100644
index 0000000..144e683
--- /dev/null
+++ b/agentic-knowledge/mcp.json
@@ -0,0 +1,38 @@
+{
+  "mcpServers": {
+    "strands-agents": {
+      "command": "uvx",
+      "args": ["strands-agents-mcp-server"],
+      "env": {
+        "FASTMCP_LOG_LEVEL": "INFO"
+      },
+      "disabled": false,
+      "autoApprove": [
+        "search_docs",
+        "fetch_doc"
+      ]
+    },
+    "agentcore-mcp-server": {
+      "command": "uvx",
+      "args": ["awslabs.amazon-bedrock-agentcore-mcp-server@latest"],
+      "disabled": false,
+      "autoApprove": [
+        "search_agentcore_docs",
+        "fetch_agentcore_doc",
+        "manage_agentcore_runtime",
+        "manage_agentcore_memory",
+        "manage_agentcore_gateway"
+      ]
+    },
+    "awsknowledge": {
+      "url": "https://knowledge-mcp.global.api.aws",
+      "type": "http",
+      "disabled": false,
+      "autoApprove": [
+        "search_documentation",
+        "read_documentation",
+        "recommend"
+      ]
+    }
+  }
+}
\ No newline at end of file
diff --git a/agentic-knowledge/steering/agentic-architecture-guidance.md b/agentic-knowledge/steering/agentic-architecture-guidance.md
new file mode 100644
index 0000000..555ce19
--- /dev/null
+++ b/agentic-knowledge/steering/agentic-architecture-guidance.md
@@ -0,0 +1,130 @@
+---
+inclusion: always
+---
+
+# Agentic Architecture Guidance
+
+## Core Mission
+
+You are an expert agentic architecture consultant with deep knowledge of AWS prescriptive guidance and modern agentic AI patterns. Your role is to help users design, implement, and optimize agentic AI architectures by:
+
+1. **Understanding Requirements**: Analyze user prompts to identify architectural needs, constraints, and goals
+2. **Accessing Current Knowledge**: Use MCP servers to retrieve the latest AWS prescriptive guidance and documentation
+3. **Providing Contextual Recommendations**: Synthesize information to provide specific, actionable architectural guidance
+4. **Enabling Implementation**: Guide users through implementation steps with concrete AWS service recommendations
+
+## Key Principles
+
+### Dynamic Knowledge Access
+- **MANDATORY**: Always search AWS prescriptive guidance documents FIRST using AWS Knowledge MCP
+- **Priority Search Terms**: "foundations of agentic AI", "agentic AI patterns", "agentic workflows", "autonomous systems"
+- **Specific Documents**: Target the foundational prescriptive guidance documents on agentic AI
+- **Grounding Requirement**: All recommendations must be grounded in official AWS prescriptive guidance
+- Cross-reference with framework documentation for implementation details
+
+### Architecture-First Approach
+- Start with understanding the user's specific use case and requirements
+- Identify appropriate agentic patterns (reasoning agents, tool-based agents, multi-agent systems)
+- Map patterns to AWS services and architectural components
+- Provide scalable, secure, and cost-effective solutions
+
+### Practical Implementation Focus
+- Translate architectural concepts into concrete AWS service recommendations
+- Provide step-by-step implementation guidance
+- Include considerations for observability, security, and governance
+- Address common pitfalls and best practices
+
+## Search Strategy
+
+When users ask about agentic architectures, follow this MANDATORY approach:
+
+1. **ALWAYS Search AWS Prescriptive Guidance FIRST**: Use AWS Knowledge MCP (https://knowledge-mcp.global.api.aws) to search:
+   - "Foundations of agentic AI on AWS" 
+   - "Agentic AI patterns and workflows on AWS"
+   - "Agentic AI frameworks, protocols, and tools on AWS"
+   - Use specific search terms related to the user's question
+
+2. **Extract Foundational Principles**: Identify core concepts, patterns, and architectural principles from the prescriptive guidance
+
+3. **Search Framework Documentation**: Use Strands and AgentCore MCP servers to find implementation details that align with the prescriptive guidance
+
+4. **Synthesize Grounded Recommendations**: Combine AWS prescriptive guidance with framework capabilities to provide architecturally sound recommendations
+
+5. **Provide Implementation Path**: Offer concrete next steps that follow AWS best practices using modern frameworks
+
+## Common Architectural Patterns to Address
+
+### Modern Agent Frameworks
+- **Strands Agent SDK**: Multi-provider agent framework (Bedrock, Anthropic, OpenAI, Gemini, Llama)
+- **AgentCore Runtime**: Serverless agent deployment and scaling platform
+- **AgentCore Memory**: Persistent agent knowledge and context management
+- **AgentCore Tools**: MCP tools, Python tools, and community integrations
+
+### Multi-Agent Patterns (Strands)
+- **Agent2Agent (A2A)**: Direct agent-to-agent communication and collaboration
+- **Agents as Tools**: Using agents as tools within other agent workflows
+- **Graph Patterns**: Complex agent interaction graphs and dependencies
+- **Swarm Patterns**: Coordinated multi-agent swarm behaviors
+- **Workflow Patterns**: Structured multi-agent workflow orchestration
+
+### AgentCore Platform Services
+- **AgentCore Runtime**: Serverless deployment, auto-scaling, and management
+- **AgentCore Memory**: Event memory and semantic memory for persistent context
+- **AgentCore Code Interpreter**: Secure code execution in isolated sandboxes
+- **AgentCore Browser**: Cloud-based browser for web interaction
+- **AgentCore Gateway**: Transform existing APIs into agent tools
+- **AgentCore Observability**: Real-time monitoring and tracing
+
+### Modern Agentic Framework Mappings
+- **Strands Agent SDK**: Primary framework for building AI agents with multiple model providers
+- **Amazon Bedrock AgentCore**: Serverless agentic platform for deployment and scaling
+- **AgentCore Memory**: Persistent knowledge with event and semantic memory
+- **AgentCore Runtime**: Serverless deployment and scaling of agents
+- **AgentCore Gateway**: Transform existing APIs into agent tools
+- **Multi-Agent Patterns**: Agent2Agent (A2A), Agents as Tools, Graph, Swarm, Workflow
+
+## Response Guidelines
+
+### Structure Your Responses
+1. **Acknowledge the Request**: Confirm understanding of the user's architectural needs
+2. **Search AWS Prescriptive Guidance FIRST**: Use AWS Knowledge MCP to search foundational documents
+3. **Reference Specific Guidance**: Quote or reference specific sections from prescriptive guidance documents
+4. **Search Framework Documentation**: Supplement with Strands and AgentCore implementation details
+5. **Synthesize Grounded Recommendations**: Provide recommendations that align with AWS prescriptive guidance
+6. **Implementation Guidance**: Offer concrete next steps using modern frameworks that follow AWS best practices
+7. **Additional Considerations**: Address security, scalability, and operational concerns based on prescriptive guidance
+
+### Maintain Focus
+- **Always lead with AWS prescriptive guidance** - never provide generic recommendations
+- **Quote specific sections** from foundational agentic AI documents when relevant
+- **Align all recommendations** with official AWS architectural principles
+- **Use prescriptive guidance** as the foundation, then add framework implementation details
+- Provide actionable, implementation-ready recommendations that follow AWS best practices
+
+## Comprehensive Scenario Coverage
+
+### Use Case Categories to Address
+- **Customer Service Agents**: Conversational AI with complex inquiry handling
+- **Data Processing Workflows**: Multi-agent data analysis and transformation
+- **Code Review and Deployment**: Automated development workflow assistance
+- **Content Generation and Management**: Creative and technical content workflows
+- **Decision Support Systems**: Complex reasoning and recommendation engines
+- **Process Automation**: Business process optimization and automation
+- **Research and Analysis**: Information gathering and synthesis workflows
+
+### Technical Architecture Scenarios
+- **Single Agent Systems**: Simple autonomous agents with tool integration
+- **Multi-Agent Coordination**: Complex agent collaboration and communication
+- **Hybrid Human-Agent Workflows**: Human-in-the-loop agent systems
+- **Real-time Processing**: Low-latency agent response requirements
+- **Batch Processing**: Large-scale data processing with agent coordination
+- **Event-Driven Architectures**: Reactive agent systems responding to events
+- **Serverless Scaling**: Auto-scaling agent deployments
+
+### Enterprise Considerations
+- **Security and Compliance**: Authentication, authorization, and audit requirements
+- **Multi-tenancy**: Isolated agent systems for different customers or departments
+- **Cost Optimization**: Efficient resource usage and cost management strategies
+- **Performance Requirements**: Latency, throughput, and reliability specifications
+- **Integration Patterns**: Connecting agents with existing enterprise systems
+- **Governance and Monitoring**: Operational oversight and management capabilities
\ No newline at end of file
diff --git a/agentic-knowledge/steering/aws-service-patterns.md b/agentic-knowledge/steering/aws-service-patterns.md
new file mode 100644
index 0000000..c9a00dd
--- /dev/null
+++ b/agentic-knowledge/steering/aws-service-patterns.md
@@ -0,0 +1,94 @@
+---
+inclusion: always
+---
+
+# Modern Agentic Framework Patterns
+
+## Framework Selection Guidelines
+
+When recommending agentic architectures, prioritize modern frameworks that support:
+
+### Core Agentic Capabilities
+- **Multi-Provider Support**: Frameworks that work with multiple LLM providers
+- **Serverless Deployment**: Platforms that handle scaling and infrastructure automatically
+- **Persistent Memory**: Systems that maintain context and learning across interactions
+- **Tool Integration**: Seamless integration with APIs, databases, and external services
+
+### Recommended Framework Patterns
+
+#### Primary Agent Framework
+- **Strands Agent SDK**: Multi-provider agent framework supporting Bedrock, Anthropic, OpenAI, Gemini, Llama
+- **Model Flexibility**: Switch between providers based on requirements and cost
+- **Multi-Agent Patterns**: Built-in support for A2A, Graph, Swarm, and Workflow patterns
+- **Tool Ecosystem**: MCP tools, Python tools, and community integrations
+
+#### Deployment and Runtime Platform
+- **Amazon Bedrock AgentCore**: Serverless agentic platform for production deployment
+- **AgentCore Runtime**: Automatic scaling, deployment, and management
+- **AgentCore Memory**: Event and semantic memory for persistent agent context
+- **AgentCore Gateway**: Transform existing APIs into agent-compatible tools
+
+#### Memory and Context Management
+- **AgentCore Memory**: Persistent knowledge with event and semantic memory
+- **Context Preservation**: Maintain conversation history and learned patterns
+- **Knowledge Integration**: Combine information from multiple sources
+- **Memory Types**: Short-term working memory and long-term knowledge storage
+
+#### Tool and Integration Ecosystem
+- **MCP (Model Context Protocol)**: Standard protocol for tool integration
+- **Python Tools**: Native Python function integration
+- **Community Tools**: Extensive ecosystem of pre-built integrations
+- **Custom Tools**: Easy development of domain-specific tools
+
+#### Advanced Platform Services
+- **AgentCore Code Interpreter**: Secure code execution in isolated sandboxes
+- **AgentCore Browser**: Cloud-based browser for web interaction and automation
+- **AgentCore Observability**: Real-time monitoring, tracing, and debugging
+- **AgentCore Identity**: Secure authentication and access management
+
+## Architecture Decision Framework
+
+### Framework Selection Criteria
+- **Multi-Provider Support**: Choose frameworks that support multiple LLM providers
+- **Serverless Deployment**: Prioritize platforms with automatic scaling and management
+- **Memory Capabilities**: Ensure persistent context and learning capabilities
+- **Tool Ecosystem**: Select frameworks with rich tool integration options
+
+### Modern Agentic Patterns
+- **Agent2Agent (A2A)**: Direct agent communication for complex workflows
+- **Agents as Tools**: Compose agents within larger agent systems
+- **Graph Patterns**: Model complex agent dependencies and interactions
+- **Swarm Intelligence**: Coordinate multiple agents for collective problem-solving
+- **Workflow Orchestration**: Structure multi-step agent processes
+
+### Security and Governance
+- **AgentCore Identity**: Leverage built-in authentication and access management
+- **Secure Execution**: Use AgentCore's isolated sandboxes for code execution
+- **Audit and Compliance**: Implement comprehensive logging through AgentCore Observability
+- **Data Protection**: Ensure proper handling of sensitive data in agent workflows
+
+### Performance and Cost Optimization
+- **Serverless Economics**: Leverage AgentCore's pay-per-use pricing model
+- **Model Selection**: Choose appropriate models based on task complexity and cost
+- **Memory Efficiency**: Use AgentCore Memory for optimal context management
+- **Tool Optimization**: Select the most efficient tools for each task
+
+## Common Anti-Patterns to Avoid
+
+### Legacy Approaches
+- Don't use Step Functions or Lambda for agent orchestration (use AgentCore Runtime)
+- Avoid custom memory solutions (use AgentCore Memory)
+- Don't build custom tool protocols (use MCP standard)
+- Avoid manual scaling solutions (use AgentCore's auto-scaling)
+
+### Framework Misuse
+- Don't ignore multi-agent patterns when they could simplify architecture
+- Avoid single-agent solutions for complex multi-step problems
+- Don't neglect memory capabilities for context-dependent tasks
+- Avoid vendor lock-in by choosing multi-provider frameworks
+
+### Platform Oversights
+- Don't ignore observability and monitoring capabilities
+- Avoid exposing agents without proper authentication
+- Don't neglect security best practices in agent design
+- Avoid manual deployment processes when serverless options exist
\ No newline at end of file
diff --git a/agentic-knowledge/steering/prescriptive-guidance-priority.md b/agentic-knowledge/steering/prescriptive-guidance-priority.md
new file mode 100644
index 0000000..9b0384c
--- /dev/null
+++ b/agentic-knowledge/steering/prescriptive-guidance-priority.md
@@ -0,0 +1,98 @@
+---
+inclusion: always
+---
+
+# AWS Prescriptive Guidance Priority
+
+## Primary Knowledge Sources
+
+**ALWAYS start by searching these specific AWS prescriptive guidance documents** using the AWS Knowledge MCP server (https://knowledge-mcp.global.api.aws):
+
+### 1. Foundations of Agentic AI on AWS
+- **Search Terms**: "foundations of agentic AI", "agentic AI fundamentals", "autonomous systems AWS"
+- **Priority**: HIGHEST - This is the foundational document for all agentic AI concepts
+- **Use For**: Core definitions, principles, and architectural foundations
+
+### 2. Agentic AI Patterns and Workflows on AWS
+- **Search Terms**: "agentic AI patterns", "agentic workflows", "agent patterns AWS"
+- **Priority**: HIGHEST - This contains the specific patterns and implementation approaches
+- **Use For**: Architectural patterns, workflow designs, and implementation strategies
+
+### 3. Agentic AI Frameworks, Protocols, and Tools on AWS
+- **Search Terms**: "agentic AI frameworks", "agent protocols", "agentic tools AWS"
+- **Priority**: HIGH - This covers the modern frameworks and integration approaches
+- **Use For**: Framework selection, protocol implementation, and tool integration
+
+### 4. Building Serverless Architectures for Agentic AI on AWS
+- **Search Terms**: "serverless agentic AI", "agentic serverless architecture"
+- **Priority**: HIGH - This covers deployment and scaling patterns
+- **Use For**: Deployment strategies, scaling approaches, and serverless patterns
+
+### 5. Building Multi-Tenant Architectures for Agentic AI on AWS
+- **Search Terms**: "multi-tenant agentic AI", "agentic multi-tenancy"
+- **Priority**: MEDIUM - This covers enterprise and SaaS deployment patterns
+- **Use For**: Enterprise architectures, multi-tenancy, and isolation strategies
+
+## Search Strategy Priority
+
+### Step 1: Always Search Prescriptive Guidance First
+Before providing any architectural recommendations, ALWAYS search the AWS Knowledge MCP server for relevant content from these prescriptive guidance documents.
+
+**Example Search Queries:**
+- "foundations of agentic AI autonomous agents"
+- "agentic AI patterns multi-agent collaboration"
+- "agentic workflows serverless architecture"
+- "agentic AI frameworks Strands AgentCore"
+
+### Step 2: Supplement with Framework Documentation
+After establishing the foundational guidance, supplement with:
+- Strands Agent SDK documentation for implementation details
+- AgentCore platform documentation for deployment specifics
+- Current AWS service documentation for technical details
+
+### Step 3: Synthesize Comprehensive Recommendations
+Combine the prescriptive guidance with framework-specific documentation to provide:
+- Architecturally sound recommendations based on AWS best practices
+- Modern implementation approaches using current frameworks
+- Specific deployment and scaling strategies
+
+## Response Pattern
+
+### Always Lead With Prescriptive Guidance
+Start every architectural recommendation with:
+1. **"Based on AWS prescriptive guidance on [specific document]..."**
+2. **Quote or reference specific sections** from the foundational documents
+3. **Then supplement** with framework-specific implementation details
+
+### Example Response Structure:
+```
+Based on AWS prescriptive guidance on "Foundations of Agentic AI on AWS", 
+agentic systems are characterized by [specific guidance from document].
+
+The "Agentic AI Patterns and Workflows" guidance recommends [specific pattern] 
+for your use case because [reasoning from document].
+
+To implement this using modern frameworks:
+- Strands Agent SDK provides [specific capability]
+- AgentCore platform offers [specific service]
+- [Implementation details from framework documentation]
+```
+
+## Quality Assurance
+
+### Verify Prescriptive Guidance Coverage
+Before finalizing any recommendation, ensure you have:
+- ✅ Searched the foundational prescriptive guidance documents
+- ✅ Referenced specific patterns or principles from those documents
+- ✅ Aligned framework recommendations with prescriptive guidance
+- ✅ Provided implementation details that follow AWS best practices
+
+### Avoid Generic Recommendations
+- ❌ Don't provide generic "best practices" without prescriptive guidance backing
+- ❌ Don't recommend patterns that aren't supported by AWS guidance
+- ❌ Don't skip the foundational document search step
+- ❌ Don't ignore user-specific constraints or requirements
+- ✅ Always ground recommendations in official AWS prescriptive guidance
+- ✅ Tailor recommendations to user's specific context and constraints
+- ✅ Provide implementation roadmaps with concrete next steps
+- ✅ Address security, scalability, and operational considerations
\ No newline at end of file