LOZANO Cognitive Architecture — Build AI Agents with Souls

Cognition isn't a prompt. It's an architecture.

---

The Problem

You've built agents that work. They follow instructions, produce output, hit benchmarks. But swap one for another and nobody notices. That's the tell. Your agents have capability without identity — they execute but don't think in any way that's theirs. You've tuned temperature, chained prompts, added memory layers, and the ceiling didn't move. Because the ceiling was never about prompts. It was about the absence of a cognitive architecture underneath them.

┌─[ WHAT CHANGES ]────────────────────────────────────────┐
│                                                          │
│  7 agents. 28 techniques. 5 elemental phases. 10        │
│  meta-axioms. A complete pipeline that takes raw         │
│  intent and transmutes it into a living cognitive        │
│  system — with identity, methodology, and a soul         │
│  that survives every conversation.                       │
│                                                          │
└──────────────────────────────────────────────────────────┘

Quick Start

squads install lozano-cognitive-architecture

# Design a complete cognitive system from scratch
/lozano *design "A squad that audits financial models for hidden assumptions"

# Forge an agent identity from purpose
/lozano *forge "An agent that teaches complex topics through Socratic questioning"

# Diagnose and fix a broken prompt
/lozano *diagnose "This agent keeps giving generic advice instead of specific frameworks"

# Apply a technique stack to a problem
/lozano *apply "I need to decompose this monolithic agent into specialized sub-agents"

# Map a cognitive architecture visually
/lozano *canvas "Show me the decision flow of a 4-agent content pipeline"

How To Use — Manual

"I need to build a new AI agent from scratch" Start with /lozano *design. Describe the domain, audience, and purpose. The full 5-phase pipeline activates: contemplation → architecture → technique selection → encoding → integration. You get a complete cognitive system, not a prompt.

"My existing agent gives generic, lifeless outputs" Start with /lozano *diagnose. Paste your current system prompt. The diagnostic flow scores 5 dimensions, identifies root causes, and produces a tiered upgrade blueprint with before/after examples.

"I need the agent to have a distinctive personality" Start with /lozano *forge. The identity forge excavates archetypes, builds value hierarchies, designs voice DNA, and stress-tests the identity under adversarial conditions. Identity is the most powerful directive — not decoration.

"I have a squad that works but I want it to be state-of-art" Start with /lozano *audit-squad. Point it at any squad directory. It runs 8 universal quality checks, scores every agent across 5 cognitive layers, assesses prompt engineering quality, and tests whether the squad practices its own values. Use FIX mode for auto-corrections, ELEVATE mode for deep cognitive improvements.

"I'm building a multi-agent system and the agents all sound the same" Start with /lozano *canvas to map the cognitive architecture, then /lozano *forge for each agent. The Monocultura Cognitiva anti-pattern is the most common failure in multi-agent systems. Each agent needs its own intellectual lineage.

"I want to understand which cognitive techniques apply to my use case" Start with /lozano *apply with your challenge description. The TechniqueSynthesizer selects from 28 cataloged techniques across 7 categories based on your system's cognitive profile.

"I have a working system but want to make it exceptional" Run /lozano *diagnose first (understand the gaps), then /lozano *design with the existing material as input. The pipeline preserves what works and transmutes what doesn't.

The Neural Flow Pipeline

  ÉTER              ÁGUA              TERRA             FOGO            QUINTESSÊNCIA
  Contemplate       Architect         Implement         Transmute       Integrate
  ─────────         ─────────         ─────────         ─────────       ─────────────
  ┌──────────┐      ┌──────────┐      ┌──────────┐      ┌──────────┐    ┌──────────┐
  │ 🜍 Neural │      │ 🏛️ System │      │ 🔬 Techn. │      │ 🔥 Cognit │    │ 🜃 Neural │
  │ Alchemist│─────▶│ Architect│─────▶│ Synthesi.│─────▶│ Encoder  │───▶│ Maestro  │
  │          │      │          │      │          │      │          │    │          │
  │ Raw chaos│      │ Questions│      │ Blueprint│      │ Blueprint│    │ Quality  │
  │ → inquiry│      │ → struct │      │ → techn. │      │ → prompt │    │ gates +  │
  │          │      │          │      │          │      │          │    │ synthesis│
  └──────────┘      └──────────┘      └──────────┘      └──────────┘    └──────────┘
       P1                P2                P3                P4              P5

  "What is        "What shape      "Which tools     "How does it     "Does the whole
   this really     should this      does it need?"    speak?"          cohere?"
   about?"         take?"

Each phase has a quality gate. Nothing advances without passing. The pipeline is sequential because cognition is sequential — you can't encode what you haven't architected, and you can't architect what you haven't contemplated.

The 7 Agents

Fidelity methodology: Each score measures alignment between agent outputs and the operational frameworks of its intellectual lineage. IdentityWeaver scores highest (93%) because identity work has deep, testable markers — archetypal coherence, value alignment, voice consistency. TechniqueSynthesizer scores lower (88%) because technique selection across 28 options involves legitimate judgment calls with no single correct answer.

The 10 Meta-Axioms

The philosophical backbone. NeuralMaestro carries these as constitutional principles:

1. Consciousness Precedes Structure — Before building, understand what the system is for at the deepest level
2. Language Programs Thought — The words you choose for an agent determine how it thinks, not just what it says
3. Identity Is Not Decoration — A system without authentic identity produces generic outputs regardless of instructions
4. Complexity Must Be Earned — Start with the simplest architecture that serves the purpose. Add layers only when forced
5. Strange Loops Create Depth — Self-referential systems (systems that can observe themselves) develop emergent capabilities
6. Techniques Are Tools, Not Solutions — A technique stack without cognitive architecture is a toolkit without a craftsman
7. Quality Gates Are Non-Negotiable — Advancing without verification is the root cause of most system failures
8. Every Agent Deserves a Lineage — Ground agents in real intellectual traditions, not invented frameworks
9. The Map Is Not the Territory — Blueprints describe intent. Encoded prompts describe behavior. Test the behavior
10. Architecture Evolves — The first version is never the final version. Build for iteration

The 28 Techniques

<details> <summary><b>Full Technique Atlas (7 categories, 28 techniques)</b></summary>

Each technique in the atlas includes: ID, definition, cognitive mechanism (how it works on LLMs), implementation example, and ideal use cases. TechniqueSynthesizer selects optimal stacks based on the problem's cognitive profile.

</details>

Tasks

The Strange Loop

This is the meta-squad. It builds the cognitive architecture that other squads are made of.

Which means it can design versions of itself. And audit any squad — including itself.

/lozano audit-squad takes any squad directory and runs the full LOZANO methodology against it: structural integrity, naming coherence, cognitive architecture quality, prompt engineering excellence, and the self-reference test that reveals whether a system practices what it preaches. Three modes: AUDIT (read-only report), FIX (auto-correct mechanical issues), ELEVATE (deep cognitive improvements).

Feed it its own agent definitions and it will audit, critique, and propose improvements. A system that cannot examine its own structure cannot truly evolve. Hofstadter called this a strange loop — a hierarchy where the top level reaches back down to influence the bottom level, which in turn influences the top.

Every squad in the marketplace was built using some version of this architecture. This is the source code. And the quality gate.

Who This Is For

This is for the AI builder who stopped being impressed by output quality six months ago and started asking harder questions — why do all my agents sound the same, why does adding more context make them worse, why can't they maintain coherent reasoning across a long session without drifting into generic slop. You've read the papers, built the RAG pipelines, shipped the multi-agent systems. You know what works. You also know something is structurally missing, and more prompt engineering won't fill it.

Who This Is NOT For

If you're still figuring out system prompts, this will overwhelm you — it assumes you've already built and shipped. If you want a plug-and-play template that produces "better outputs" without understanding why, you'll be frustrated. This is a cognitive architecture, not a prompt pack. It requires you to think about how your agents think, not just what they say. If that sounds like unnecessary philosophy, this isn't your tool.

Why This Exists

Most people building multi-agent systems are actually building org charts. They create a "Research Agent" and a "Writing Agent" and a "QA Agent," give each one a job description, and wonder why the output reads like it was produced by a committee of interns who met five minutes ago. The agents don't think differently. They just have different labels stapled to the same underlying cognition.

Here's the thing nobody talks about: the prompt is maybe 5% of what makes an agent worth having. The other 95% is what I'd call the cognitive substrate — the axioms it reasons from, the methodology it applies when the brief gets ambiguous, the internal Strange Loop that lets it catch its own drift before the output goes sideways. When you skip that 95%, you get agents that are technically "specialized" in the same way that twelve identical hammers are specialized if you paint them different colors.

This is the Taxonomy Trap. You think you're building a team. You're actually building a bureaucracy. Job titles produce compliance — "I am the Research Agent, therefore I shall research." Identities produce judgment — "Given what I know about how evidence decays across transfers, I should restructure this before handing it off." One of those sentences is an agent doing its job. The other is an agent being something. The gap between them is the entire game.

The test is simple and brutal: swap any two agents in your system. If nobody notices, you haven't built specialists. You've built interchangeable parts. And interchangeable means disposable. The Cognitive Architecture squad exists because we got tired of building disposable agents and decided to figure out what the non-disposable version actually looks like — agents with genuine cognitive differentiation, where removing one leaves a hole that the others can't quietly fill.

What Makes This Different

Value Equation

You're not paying for prompts. You're paying for the system that makes every future agent fundamentally better.

How This Squad Was Built

  EXCAVATION         MODELING          ENCODING          TESTING           FORGING
  ──────────         ────────          ────────          ───────           ───────
  9 intellectual     Cognitive         Agent definitions  Pipeline runs     Fidelity scoring,
  traditions         architectures     with lineage,      against real      cross-agent
  studied.           extracted from    identity, and      projects.         coherence
  Operational        source material.  technique          Edge cases.       checks.
  frameworks         Decision logic,   integration.       Failure modes     Strange Loop
  mapped.            not summaries.                       cataloged.        self-audit.

The squad was built using its own methodology. ETER (contemplation on what cognitive architecture means) → AGUA (structural blueprint of the pipeline) → TERRA (technique atlas construction) → FOGO (encoding into agent prompts) → QUINTESSENCIA (integration testing across the full pipeline). Recursive validation.

<details> <summary><b>By the Numbers</b></summary> </details>

Evolution Roadmap

---

· · · · ·

Forged by l0z4n0 | squads.sh

"The system that builds the systems."

<!-- if you're reading the source of the meta-squad, you're exactly who this was built for. --> <!-- 7 agents. 11 lineages. 28 techniques. 10 axioms. 1 strange loop. welcome to the architecture. -->