mikeparcewski/five-layer-architecture
skills/agentic/five-layer-architecture/SKILL.md
Five-layer architectural model for building production-grade agentic systems with clear separation of concerns. Use when: "agent architecture layers", "five layer", "agent system design", "separation of concerns agents"
$ install --global
skillsauthnpx skillsauth add mikeparcewski/wicked-garden five-layer-architectureInstall this skill globally with one command. Works with Claude Code, Cursor, and Windsurf.
Security Scan Results
3 of 9 scanners reported clean
Some scanners were skipped, did not run, or reported a non-clean status. Review each row below.
3
Scanners Passed
9
Scanners in report
Clean
TrivyContainer and dependency vulnerability scanner
95%
Clean
SemgrepStatic code analysis for vulnerabilities
95%
Clean
mcp-scan (Snyk)Model Context Protocol security validation
95%
Skipped
Snyk (dep)Open source security scanning
50%
Skipped
Socket.devSupply chain security analysis
50%
Skipped
VirusTotalMulti-engine malware detection
50%
Skipped
CrowdStrikeAdvanced threat intelligence
50%
Skipped
OSV-ScannerOpen Source Vulnerability database check
50%
Skipped
OWASP Dep-Check
50%
Last scanned: Apr 16, 2026, 5:58 AM6.8s6 files scanned
SKILL.md
- name:
- five-layer-architecture
- description:
- |
- Use when:
- agent architecture layers", "five layer", "agent system design", "separation of concerns agents
- portability:
- portable
Five-Layer Architecture
A layered architecture model for agentic systems that separates concerns and enables scalable, maintainable, production-ready systems.
The Five Layers
┌─────────────────────────────────────┐
│ Layer 5: Governance │ Safety, compliance, audit
├─────────────────────────────────────┤
│ Layer 4: Runtime │ Execution, monitoring, scaling
├─────────────────────────────────────┤
│ Layer 3: Interaction │ Tools, APIs, communication
├─────────────────────────────────────┤
│ Layer 2: Context │ Memory, state, knowledge
├─────────────────────────────────────┤
│ Layer 1: Cognition │ Reasoning, planning, decisions
└─────────────────────────────────────┘
Layer 1: Cognition
Core intelligence - reasoning, planning, and decision-making.
- Task understanding and decomposition
- Planning and strategy formulation
- Reasoning patterns (ReAct, Chain-of-Thought)
- Meta-cognition and self-reflection
- Anti-pattern: Mixing business logic into prompts, no separation between reasoning and action
Layer 2: Context
Memory, state, and knowledge management.
- Short-term working memory (conversation history)
- Long-term memory (persistent knowledge, vector search)
- State management and checkpointing
- Context window optimization and compression
- Anti-pattern: Passing entire history to every agent (context bloat)
Layer 3: Interaction
Tools, APIs, and communication channels.
- Tool/function registry and execution
- External API integration with error handling
- Multi-agent communication protocols
- Rate limiting, retry logic, serialization
- Anti-pattern: Tight coupling, no retry/timeout, missing input validation
Layer 4: Runtime
Execution environment, monitoring, and scaling.
- Agent lifecycle management (start, stop, restart)
- Concurrent execution and orchestration
- Observability (logging, tracing, metrics)
- Resource quotas, health checks, circuit breakers
- Anti-pattern: No observability, no resource limits, synchronous bottlenecks
Layer 5: Governance
Safety, compliance, and audit.
- Safety guardrails and action constraints
- Human-in-the-loop approval gates
- Audit logging, traceability, compliance
- PII detection, access control, rollback
- Anti-pattern: No approval gates, missing audit trails, no rollback
Layer Interaction Patterns
Bottom-Up Flow: Cognition decides → Context provides info → Interaction executes → Runtime monitors → Governance validates
Top-Down Constraints: Governance sets policies → Runtime enforces limits → Interaction restricts tools → Context filters sensitive data → Cognition operates within constraints
Cross-Layer: Observability, security, error handling, and performance optimization span all layers.
Designing a New System
- Start with Cognition: What reasoning/planning capability do you need?
- Add Context: What information must agents remember?
- Define Interaction: What tools/APIs do agents need?
- Build Runtime: How will you execute, monitor, scale?
- Implement Governance: What safety/compliance is required?
Quick Reference
| Layer | Focus | Key Question | Example Component | |-------|-------|--------------|-------------------| | 1. Cognition | Intelligence | "What should I do?" | LLM reasoning | | 2. Context | Memory | "What do I know?" | Vector database | | 3. Interaction | Tools | "How do I act?" | API clients | | 4. Runtime | Execution | "Is it working?" | Monitoring | | 5. Governance | Safety | "Is it safe?" | Approval gates |
When to Use
- "How should I architect my agentic system?"
- "Where does [component] belong in the architecture?"
- "My system is getting messy and hard to maintain"
- "How do I separate concerns in my agent system?"
References
refs/layers-cognition-context.md- Layer 1 (Cognition) and Layer 2 (Context) with implementation patternsrefs/layers-interaction-runtime.md- Layer 3 (Interaction) and Layer 4 (Runtime) with implementation patternsrefs/layers-governance-integration.md- Layer 5 (Governance) and cross-layer integration examplerefs/implementation-guide-layers-1-3.md- Building Layers 1-3 (Cognition, Context, Interaction)refs/implementation-guide-layers-4-5.md- Building Layers 4-5 (Runtime, Governance) and complete system
Related Skills
mikeparcewski/skills/engineering/large-scale-migration
development
VerifiedTrustedCommunity
--- name: large-scale-migration description: How to execute a LARGE MECHANICAL change across any codebase with LEVERAGE instead of an agent-grind or hand-edits — a cross-cutting migration, refactor, rename, dialect/framework/DB port, library adoption, or bulk transform. The map→transform→gate pattern: a deterministic transform driven by a source-of-truth map, proven by a differential-equivalence gate. Use when the work is "migrate all X to Y", "rename Z everywhere", "port to a new DB/dialect/fra
8SKILL.mdUpdated Jun 3, 2026
mikeparcewski/wicked-garden:classify
testing
VerifiedTrustedCommunity
v11 LLM-based work-shape classifier. Replaces the regex archetype detector with the model's own reasoning. Reads the user's prompt, picks the right archetype(s) from the catalog, identifies signals (blast_radius, novelty, reversibility, etc.), and persists to SessionState so subsequent turns steer correctly. Use when: the prompt_submit hook emitted a `<wg classify-due />` directive, OR explicitly invoked at session start, OR when re-classifying after the user changes scope mid-session.
8SKILL.mdUpdated May 26, 2026
mikeparcewski/wicked-garden:archetype
tools
VerifiedTrustedCommunity
v11 work-shape archetype runner. When a prompt has been routed to one of the 9 archetypes (triage, explore, specify, decide, ship, review, incident, build, migrate), this skill is the entry point. It picks the right per-archetype playbook from refs/ and executes the phase shape declared in `.claude-plugin/archetypes.json`. Use when: a `<wg archetype="X">` or `<wg archetypes>` system-reminder tag appears, an explicit "let's run the X archetype" request, or when one of the per-archetype slash commands resolves to this skill.
8SKILL.mdUpdated May 8, 2026
mikeparcewski/intent
development
VerifiedTrustedCommunity
Show or set the session intent variable. Intent gates how loud the framework is — simple-edit (silent), feature/research (synthesis directive), rigor (full crew context). Auto-detected on turn 1; this skill overrides explicitly. Sticky for the session. Use when: "set intent", "intent override", "/wicked-garden:intent", "make the framework quiet", "force rigor", "what's my intent".
8SKILL.mdUpdated May 6, 2026