cognitive-systems-engineering

Engineer cognitive architectures with persistent memory, decision cycles, and multi-agent coordination.

Updated Feb 20, 2026
One-click install
npx skills add https://github.com/KrystianYCSilva/math-theory-lib --skill cognitive-systems-engineering
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: cognitive-systems-engineering
Source: https://github.com/KrystianYCSilva/math-theory-lib/tree/main/.codex/skills/cognitive-systems-engineering
Command: npx skills add https://github.com/KrystianYCSilva/math-theory-lib --skill cognitive-systems-engineering

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill helps architects and engineers move beyond stateless prompt-response agents by providing blueprints for persistent, goal-directed AI minds that manage memory, make repeatable decisions, and coordinate multiple specialist agents.

Core Features & Use Cases

  • Tiered Memory Design: Patterns for Working, Episodic, Semantic, and Procedural memory using sliding windows, vector stores (RAG), and context files.
  • Decision Cycle Implementations: Guidance for choosing and implementing OODA, ReAct, or production decision loops with retry counters and escalation.
  • Multi-Agent Patterns: Orchestrator-workers, blackboard, pipeline, and debate topologies for decomposing complex tasks across specialists.
  • Use Case: Build a customer-support agent that retains session context, retrieves past interactions via embeddings, chooses tools to act, and delegates billing tasks to a payment worker.

Quick Start

Design a cognitive agent architecture with working, episodic, semantic, and procedural memory, select an OODA or ReAct decision cycle, and propose a multi-agent pattern for coordinating tool use and retries.

Frequently Asked Questions about cognitive-systems-engineering

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

FAQPage Schema
How do I design a cognitive architecture for AI agents with persistent memory?

Design a cognitive architecture by implementing tiered memory patterns for working, episodic, semantic, and procedural memory using sliding windows, vector stores, and context files. This approach provides persistent, goal-directed AI agents that manage memory and make repeatable decisions.

What is the best way to implement decision cycles for multi-agent coordination?

The best way to implement decision cycles for multi-agent coordination is to select OODA or ReAct loops with retry counters and escalation. Pair these with orchestrator-workers, blackboard, pipeline, or debate topologies to decompose complex tasks across specialist agents.

How does RAG integrate with episodic and semantic memory in AI agents?

RAG integrates with episodic and semantic memory by using vector stores to retrieve past interactions and relevant knowledge via embeddings. This grounds the agent, allowing it to retain session context and retrieve historical data for production decision logic.

Can I use OODA or ReAct patterns for production agent retry and escalation logic?

Yes, you can use OODA or ReAct patterns for production agent retry and escalation logic. These decision cycles support tool integration and high-stakes verification by providing structured loops with retry counters and explicit escalation pathways.

When do I need multi-agent patterns for orchestrating AI tool use?

You need multi-agent patterns for orchestrating AI tool use when decomposing complex tasks across specialists, such as customer support or data pipelines. Orchestrator-workers and debate topologies coordinate tool use, retries, and task delegation.

What are the limitations of stateless prompt-response agents in production environments?

Stateless prompt-response agents lack persistent memory, repeatable decision cycles, and multi-agent coordination. This prevents them from retaining session context, retrieving past interactions via embeddings, or delegating specialized tasks in high-stakes verification scenarios.