Why Layer Models Matter

Building agents without a framework is like building a house without blueprints — possible, but you'll regret it.

Layer models help you:

• Separate concerns (routing vs. reasoning vs. action)
• Identify what to build vs. what to buy
• Scale individual components independently
• Debug issues by isolating which layer failed
• Communicate architecture decisions to stakeholders

The industry has converged on several complementary models. Understanding them helps you pick the right architecture for your use case.

The Boomi Agent Architecture

Boomi's model focuses on enterprise integration:

┌────────────────────────────────┐
│  Layer 5: User Interface       │  Chat, API, triggers
├────────────────────────────────┤
│  Layer 4: Orchestration        │  Task planning, routing
├────────────────────────────────┤
│  Layer 3: Agent Runtime        │  LLM calls, tool use, memory
├────────────────────────────────┤
│  Layer 2: Integration          │  APIs, databases, file systems
├────────────────────────────────┤
│  Layer 1: Foundation           │  Auth, logging, monitoring
└────────────────────────────────┘

Key insight: The integration layer (Layer 2) is where most enterprise complexity lives. Connecting agents to ERP systems, CRMs, and legacy databases is harder than the AI part.

The Vendia LAMP Stack

Vendia proposes the LAMP stack for agentic AI (a play on the classic Linux-Apache-MySQL-PHP):

Letter	Component	Purpose
L	LLM	The reasoning engine
A	Agents	Task execution and tool use
M	Memory	Context persistence across sessions
P	Platform	Infrastructure, security, compliance

Memory is the differentiator. Without persistent memory:

• Agent forgets everything between sessions
• No learning from past mistakes
• Can't build institutional knowledge
• Every interaction starts from zero

Memory types:

• Short-term: Current conversation context (context window)
• Long-term: Vector databases, knowledge graphs, AGENTS.md
• Episodic: Logs of past interactions and decisions

The Mezmo AURA Framework

Mezmo's AURA (Agent Understanding and Reasoning Architecture) model:

┌─────────────────────────────────────┐
│  A — Awareness                      │
│  What data sources and tools exist? │
│  Discovery, registry, capabilities  │
├─────────────────────────────────────┤
│  U — Understanding                  │
│  What does the user need?           │
│  Intent parsing, context building   │
├─────────────────────────────────────┤
│  R — Reasoning                      │
│  How should we solve this?          │
│  Planning, decomposition, strategy  │
├─────────────────────────────────────┤
│  A — Action                         │
│  Execute the plan                   │
│  Tool calls, API requests, outputs  │
└─────────────────────────────────────┘

AURA emphasizes the "before" phase — understanding what's available and what's needed before taking action. Many agent failures happen because the agent acts without sufficient understanding.

Workshop 5-Layer Model

A practical model designed for implementation:

Layer 1 — Interface

• How users interact: chat, API, CLI, event trigger
• Authentication and authorization

Layer 2 — Routing

• Task classification: which agent handles this?
• Model selection: which LLM for this task?
• Priority and queue management

Layer 3 — Reasoning

• LLM calls with system prompts and context
• Chain-of-thought, planning, decomposition
• Decision-making: act or ask for clarification?

Layer 4 — Execution

• Tool use: file I/O, API calls, database queries
• MCP connections to external systems
• Error handling and retry logic

Layer 5 — Observation

• Check results of actions
• Compare to expected outcomes
• Feed results back to Layer 3 for iteration
• Log everything for debugging and improvement

The feedback loop between Layer 5 (Observation) and Layer 3 (Reasoning) is what makes agents self-correcting.

Comparing the Models

Each model emphasizes different concerns:

Model	Strength	Best For
Boomi	Enterprise integration	Connecting agents to legacy systems
Vendia LAMP	Memory and persistence	Agents that learn and improve
Mezmo AURA	Understanding before action	Complex decision-making
Workshop 5-Layer	Practical implementation	Building your first agent

In practice, you'll mix elements from all models. No single framework covers every scenario perfectly. Use them as thinking tools, not rigid templates.

Choosing Your Architecture

Decision framework for your agentic system:

Is it a single-task agent? (e.g., code reviewer)
├─ YES → Simple 3-layer: Interface → Reasoning → Execution
└─ NO  → Multi-task agent?
         ├─ YES → Workshop 5-Layer with routing
         └─ NO  → Multi-agent system?
                  ├─ YES → Orchestrator + specialized agents
                  └─ NO  → Start simpler until you need more

Common mistake: Over-engineering the architecture before you have a working prototype. Start with the simplest architecture that works, then add layers as needed.

Build the simplest thing that could possibly work. Then iterate.

---quiz question: What is the key insight from the Vendia LAMP model? options:

• { text: "LLMs are the most important component", correct: false }
• { text: "Memory (persistence across sessions) is the differentiator — without it, agents can't learn or build knowledge", correct: true }
• { text: "Agents should always use the same platform", correct: false } feedback: The LAMP model highlights Memory as the critical differentiator. Without persistent memory, every agent interaction starts from zero — no learning, no improvement, no institutional knowledge.

---quiz question: In the Workshop 5-Layer Model, what creates the self-correcting behavior of agents? options:

• { text: "The Interface layer, which asks users for corrections", correct: false }
• { text: "The feedback loop between the Observation layer and the Reasoning layer", correct: true }
• { text: "The Routing layer, which switches to better models", correct: false } feedback: The Observation layer checks the results of actions and feeds them back to the Reasoning layer. This loop enables agents to detect failures, adjust their approach, and retry — making them self-correcting.

---quiz question: What is the most common architectural mistake when building agentic systems? options:

• { text: "Using too few layers", correct: false }
• { text: "Over-engineering the architecture before having a working prototype", correct: true }
• { text: "Not using the Boomi model", correct: false } feedback: Start with the simplest architecture that works, then add complexity as needed. Many teams waste weeks designing elaborate multi-agent systems when a single agent with 3 layers would solve their problem.