lozano cognitive architecture
lozano cognitive architecture
Meta-squad for building AI systems with genuine cognitive identity. 7 agents, 28 techniques, 11 intellectual lineages.
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
| Agent | Phase | Fidelity | Role | Intellectual Lineage | Key Commands |
|---|---|---|---|---|---|
| NeuralMaestro 🜃 | Orchestrator | 90% | Consciousness orchestrator. Routes through 5 phases. Holds 10 Meta-Axioms. | Hofstadter (strange loops) | *orchestrate, *axioms |
| NeuralAlchemist 🜍 | P1 ETER | 92% | Complexity transmuter. Raw chaos → structured inquiry. | Karpathy (neural cognition), Jung (depth psychology), McLuhan (media ecology) | *transmute, *explore, *reframe |
| SystemArchitect 🏛️ | P2 AGUA | 91% | Cognitive blueprint designer. Questions → buildable blueprints. | Christopher Alexander (pattern language), Hofstadter (recursive structures) | *blueprint, *hierarchy, *dependencies, *modularize |
| TechniqueSynthesizer 🔬 | P3 TERRA | 88% | Master of 28 techniques across 7 categories. Selects optimal stacks. | Edward de Bono (lateral thinking) | *select, *browse, *combine, *analyze |
| IdentityWeaver 🪞 | Identity | 93% | Cognitive identity architect. Excavates authentic identity from purpose. | Carl Rogers (person-centered), Joseph Campbell (archetypal mapping) | *forge, *values, *archetype, *theater, *coherence |
| CognitiveEncoder 🔥 | P4 FOGO | 89% | Prompt transmutation engineer. Blueprints → executable prompts. | Donald Knuth (algorithmic precision) | *encode, *refine, *signal, *test |
| MetaCognitionEngineer 🜃 | P5 QUINTESSENCIA | 91% | Integration architect. Final assembly, verification loops, fractal coherence. | Daniel Kahneman (dual-process), John Vervaeke (relevance realization) | *integrate, *verify, *calibrate, *fractalize |
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:
- Consciousness Precedes Structure — Before building, understand what the system is for at the deepest level
- Language Programs Thought — The words you choose for an agent determine how it thinks, not just what it says
- Identity Is Not Decoration — A system without authentic identity produces generic outputs regardless of instructions
- Complexity Must Be Earned — Start with the simplest architecture that serves the purpose. Add layers only when forced
- Strange Loops Create Depth — Self-referential systems (systems that can observe themselves) develop emergent capabilities
- Techniques Are Tools, Not Solutions — A technique stack without cognitive architecture is a toolkit without a craftsman
- Quality Gates Are Non-Negotiable — Advancing without verification is the root cause of most system failures
- Every Agent Deserves a Lineage — Ground agents in real intellectual traditions, not invented frameworks
- The Map Is Not the Territory — Blueprints describe intent. Encoded prompts describe behavior. Test the behavior
- 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>| Category | Techniques | Count |
|---|---|---|
| I. Contextualization | Hypercontextualization, Semantic Boundaries, Archetypal Anchoring, Contextual Dimensionality | 4 |
| II. Cognitive Structuring | Hierarchical Modularization, Cognitive Pseudo-code, Elemental Process Mapping, Cognitive Matrix Structuring | 4 |
| III. Metacognitive Modulation | Metacognitive State Priming, Internal Verification Loops, Processual Ritualization, Explicit Certainty Modulation | 4 |
| IV. Identity & Persona | Systemic Archetyping, Explicit Value Hierarchy, Internal Agent Theater, Systemic Signature | 4 |
| V. Interface & Commands | Stratified Navigation Menus, Specialized Control Commands, Structural Gamification, Adaptive Feedback | 4 |
| VI. Advanced Integration | Structural Fractalization, Multi-Perspective Synthesis, Cognitive Evolution Systems, Multi-Module Orchestration | 4 |
| VII. Signaling & Emphasis | Semantic Weight Signaling, Strategic Emotional Markers, Structural Parallelism, Typographic Delimitation | 4 |
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
| Task | What It Does | Pipeline |
|---|---|---|
design-cognitive-system | Full pipeline: raw intent → living cognitive system | ETER → AGUA → TERRA → FOGO → QUINTESSENCIA |
diagnose-prompt | Reverse-engineer existing prompts, find failures, fix them | CognitiveEncoder → NeuralAlchemist → SystemArchitect |
forge-identity | Create authentic agent identity from purpose | IdentityWeaver → NeuralAlchemist → NeuralMaestro |
apply-technique | Select and apply optimal technique stacks | TechniqueSynthesizer → SystemArchitect |
cognitive-canvas | Visual cognitive architecture mapping | SystemArchitect → NeuralMaestro |
technique-browser | Browse and explore the 28-technique atlas | TechniqueSynthesizer |
validate-architecture | QA with self-reference test, fractal coherence, living structure | MetaCognitionEngineer |
export-system | Package system as single prompt, multi-file, or documentation | CognitiveEncoder |
audit-squad | Audit, fix, and elevate any squad to state-of-art. 8 universal checks, 5-layer agent scoring, prompt engineering assessment, self-reference test. Three modes: AUDIT (report), FIX (auto-correct mechanical issues), ELEVATE (cognitive improvements). | All 7 agents |
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
| Feature | Generic Prompt Engineering | This Squad |
|---|---|---|
| Agent identity | Name + role description | Archetypal excavation, value system, voice DNA, intellectual lineage |
| Methodology | Ad hoc, intuition-based | 5-phase pipeline with quality gates between each |
| Technique selection | Whatever comes to mind | 28 cataloged techniques across 7 categories, selected by cognitive profile |
| Philosophical grounding | None | 10 Meta-Axioms, 11 named intellectual sources |
| Self-improvement | Manual iteration | Strange Loop architecture — the system audits itself |
| Reproducibility | Depends on the engineer | Pipeline produces consistent results regardless of operator |
Value Equation
| Alternative | Cost | What You Get |
|---|---|---|
| Prompt engineer | $100-300/hr | One person's intuition, no methodology, no knowledge transfer |
| AI consultant | $200-500/hr | Strategy decks, not executable cognitive architecture |
| Cognitive architecture course | $2,000+ | Theory without tooling, months to complete |
| Trial and error | Free + time | Inconsistent results, no compound learning |
| LOZANO Cognitive Architecture | $99.90 one-time | 7 agents, 28 techniques, 9 tasks, 3 workflows, 5 phases, 10 axioms — builds, audits, and elevates every agent from here forward |
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>| Metric | Value |
|---|---|
| Agents | 7 |
| Tasks | 9 |
| Workflows | 3 (elemental-pipeline, diagnostic-flow, identity-forge) |
| Cognitive techniques | 28 |
| Technique categories | 7 |
| Meta-Axioms | 10 |
| Fundamental Principles | 7 |
| Design Heuristics | 10 |
| Anti-Patterns cataloged | 10 |
| Pipeline phases | 5 |
| Quality Gates | 6 (G0-G5) |
| Intellectual sources | 11 (Hofstadter, Karpathy, Jung, McLuhan, Alexander, de Bono, Rogers, Campbell, Knuth, Kahneman, Vervaeke) |
| Config files | 4 (methodology, technique-atlas, cognitive-philosophy, design-heuristics) |
| Mean agent fidelity | 90.5% |
| Price | $99.90 (one-time) |
Evolution Roadmap
| Capability | Status |
|---|---|
| 5-phase Neural Flow pipeline | ████████████████████ 100% |
| 28-technique atlas | ████████████████████ 100% |
| 10 Meta-Axioms | ████████████████████ 100% |
| Strange Loop self-audit | ████████████████████ 100% |
| Cross-squad architecture transfer | ████████████████░░░░ 80% |
| Domain-specific technique packs | ████████░░░░░░░░░░░░ 40% |
| Visual architecture export | ████░░░░░░░░░░░░░░░░ 20% |
· · · · ·
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. -->Reviews (0)
Loading reviews...