Every working agentic marketing system - whatever the vendor, whatever the demo - stands on the same five layers. Knowing them serves two purposes: it turns vague platform evaluations into pointed questions ("show me your budget enforcement"), and it explains most failed agent projects in one glance, because the postmortem almost always reads "we had three of the five". This guide walks each layer: what it does, what good looks like, where the build-versus-buy line sits, and which pieces teams consistently overbuy.
The five layers
| Layer | Job | Evaluation question |
|---|---|---|
| Models | Plan, adapt, write | Can tiers be routed per task, and swapped as models improve? |
| Tools | Act on real systems and data | Typed? Metered? Scoped? What data sources are first-party? |
| Memory | Context across steps, sessions, surfaces | Does a thread started in Slack continue in the console? |
| Budgets | Bound the cost of any run | Reserved before execution, or checked after the money moved? |
| Approvals | Gate consequential writes | Does approving execute the exact reviewed call? |
Layer one: reasoning models
The model layer plans missions, adapts when results surprise, and writes the prose in deliverables. The practical insight after two years of production use: model choice is a routing decision, not a loyalty decision. Frontier models earn their cost on planning and long-form synthesis; mid-tier models handle classification and extraction at a fraction of the price; and the assignments should be revisited quarterly, because the frontier moves and yesterday's flagship-only task is today's mid-tier task. Platforms that hard-wire one model everywhere either overspend on easy work or underperform on hard work - usually both, in different places.
A second routing dimension matters for anyone producing customer-facing text: multi-model pipelines, where one model plans, another drafts and a third rewrites for voice. The stages fail differently, which is the point - the pipeline pattern appears again in content operations.
Layer two: the tool layer
The tool layer is where an agent stops being a chatbot: keyword pricing, firmographic lookups, ad-library reads, email verification, CRM writes, site audits - each a typed, permissioned, metered capability. Three properties separate a production tool layer from a demo integration. Typing: inputs are validated schemas, so a malformed call fails fast instead of corrupting downstream. Metering: every call has a price the budget layer can reserve against. Scoping: a mission carries permissions for the tools it was granted and nothing else, which is what bounds the blast radius of any single run - the mechanics appear in the execution walkthrough.
Evaluate this layer on its data as much as its plumbing. An agent is only as good as what it can observe: live keyword economics, real ad libraries, actual buying signals, your own analytics. Thin data behind beautiful orchestration produces confident reports about nothing - the pattern to catch in any trial.
Layer three: memory
Memory operates at three scopes, and conflating them causes most confusion. Mission memory holds one run's accumulating evidence. Thread memory carries conversation context across sessions and surfaces - the property that lets a discussion started in Slack continue in the console without re-explaining, and the reason chat-based agent surfaces feel like colleagues rather than kiosks. Workspace memory holds durable facts: the brand voice, the ICP, the competitor set, the preferences worth never repeating. Underbuilt memory shows up as agents that re-research known facts and re-ask answered questions; overbuilt memory shows up as vector-database projects that delay the program by a quarter - the skip-list below returns to that.
Layer four: budgets and metering
Budgets convert "AI spend anxiety" into arithmetic, and the design bar is specific: cost ceilings are reserved before execution and settled after, per mission and per period, enforced by a ledger that refuses work exceeding the envelope - with a structured, machine-readable stop when the ceiling is reached. The full pattern, including ordered degradation when a mission cannot afford its ideal plan, is in the budget design article and Metering that actually stops. The evaluation trap to avoid: dashboards that display spend are reporting; only enforcement below the agent is control.
Layer five: approvals and audit
The approvals layer holds the line between reads and writes: research runs free, while spends, sends and publishes park with their exact arguments until a human decides - the queue design that keeps this fast rather than bureaucratic. The audit half records every call, cost and decision so trust is inspectable. Together they are what let the governance of autonomous AI agents graduate autonomy on evidence: gate everything at first, promote mission types as their queue history proves boring.
The build-vs-buy line
The line falls where it usually falls in infrastructure: build what encodes your differences, buy what is undifferentiated weight. Your data connections, your approval policies, your brand rules, your scoring rubrics - those are yours and worth owning. Orchestration loops, tool metering, budget ledgers, queue mechanics, idempotent delivery - that is months of engineering that looks identical at every company that builds it, which is the textbook case for buying. Teams with strong engineering sometimes take the middle road: a platform over MCP, their own agents on top, the governed tool layer underneath - the API-first shape exists for exactly that pattern.
What teams overbuy
Three purchases recur in stalled programs. Vector databases bought before any retrieval problem exists - most marketing missions read live sources, and workspace memory needs are modest at the start. Fine-tuning commissioned before prompting and pipelines were exhausted - voice and format are overwhelmingly prompt-layer problems in 2026. Observability dashboards stood up before there is anything to observe - the mission audit trail is the observability, and a weekly read of it beats a wall of panels nobody opens. The common thread: infrastructure purchased as a substitute for running missions. The corrective is the same as ever - run real objectives early, let the gaps you actually hit dictate the next purchase.
Frequently asked questions
What does a complete agentic marketing stack include?
Five layers: reasoning models routed by task tier, a typed and metered tool layer over real data, memory across missions and threads, reserve-then-settle budgets, and approval gates with audit trails. Production requires all five.
Should we build our own agent stack?
Build what encodes your business - data connections, policies, rubrics. Buy the undifferentiated machinery: orchestration, metering, ledgers, queues. The MCP middle road lets engineering teams build agents on a governed platform rather than from bare metal.
Which model should agents use?
Tiers, routed per task: frontier models for planning and synthesis, mid-tier for classification and extraction at volume - revisited quarterly as the frontier moves. Single-model-everywhere designs overspend and underperform simultaneously.
Do we need a vector database?
Not until a concrete retrieval problem exists. Most marketing missions read live sources, and early workspace memory fits simpler storage. It is the most common premature purchase in agent programs.
What is the most commonly missing layer?
Budgets and approvals - the governance pair. Programs demo without them and die in production without them, either through a surprise invoice or one ungated write that burns organizational trust.
Sources
- Model Context Protocol - the standard for exposing tool layers to agents
- Anthropic - Building effective agents
Every playbook on this blog ships as a runnable mission.
Open a workspace and the playbook library is waiting - describe the outcome and the agents carry it end to end, on your plan's monthly credits.