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.