Agent Architecture Patterns

Identify and apply Reflection, Planning, Tool Use, Multi-Agent, and Memory patterns for local AI agents.

Updated Jan 12, 2026
One-click install
npx skills add https://github.com/seanspiesman/Agents-and-Workflows --skill agent-architecture-patterns
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: Agent Architecture Patterns
Source: https://github.com/seanspiesman/Agents-and-Workflows/tree/main/custom-agents/skills/agent-architecture-patterns
Command: npx skills add https://github.com/seanspiesman/Agents-and-Workflows --skill agent-architecture-patterns

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This collection defines actionable architectural patterns for local AI agents, enabling reliable reasoning, structured planning, deterministic tool use, coordinated collaboration, and memory-aware context management.

Core Features & Use Cases

  • Reflection pattern to reduce hallucinations via iterative self-critique and refinement.
  • Planning pattern to decompose complex goals into atomic tasks with clear validation.
  • Tool Use pattern to interact with external environments through a request-response loop.
  • Multi-Agent collaboration to assign roles, hand off data, and aggregate outputs.
  • Memory & Context pattern to maintain state and context across sessions.

Quick Start

Apply these patterns to a task by drafting an initial agent response, evaluating it critically, and refining it before finalization.

Frequently Asked Questions about Agent Architecture Patterns

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
What are the core architectural patterns for building local AI agents?▼

Core architectural patterns for local AI agents include Reflection for iterative self-critique, Planning for task decomposition, Tool Use for external interaction, Multi-Agent for role collaboration, and Memory for state management across sessions.

How do I apply the reflection pattern to reduce hallucinations in AI agents?▼

Apply the reflection pattern by drafting an initial agent response, evaluating it critically for hallucinations, and refining the output through iterative self-critique before finalization to improve reasoning reliability.

How do I decompose complex goals into atomic tasks for multi-agent workflows?▼

Decompose complex goals into atomic tasks using the Planning pattern, which structures multi-agent workflows by defining deterministic operating flows with clear validation steps and separating planning from execution.

Can I use these architecture patterns to coordinate multiple local AI agents?▼

Yes, you can coordinate multiple local AI agents using the Multi-Agent pattern to assign specific roles, hand off data between agents, and aggregate individual outputs into a cohesive final result.

What is the best way to maintain context and state across local AI agent sessions?▼

The best way to maintain context and state across local AI agent sessions is implementing the Memory pattern, which enables memory-aware context management to preserve information between interactions.

When should I separate planning, execution, and memory in local AI agent architectures?▼

Separate planning, execution, and memory in local AI agent architectures when designing complex agent-based workflows or debugging reasoning chains to ensure modular pattern definitions and deterministic operating flows.