The Five Layers, Explained Simply
Skip a layer and the whole stack degrades — here's what each of the five Conductor Stack layers does and why every one of them is load-bearing.
Introduction
In the last lesson, we established the mental model: AI as an orchestra you conduct, not a chat window you type into. Now let's make that concrete. The Conductor Stack has exactly five layers, and each one does a specific job. Miss any of them and the system degrades — usually in ways that feel random until you understand the architecture.
This lesson walks each layer from top to bottom. By the end, you'll have a blueprint you can apply to any automation project.
Core Concept
Layer 1 — The Conductor (You)
The conductor is the person who defines what the system should accomplish. You're not writing every prompt, not clicking every button. You're making two decisions: what outcome matters, and how the layers below should be structured to produce it.
Good conductors think in systems. What are the inputs? What are the outputs? What's the routing logic — which skill handles which task? What should happen when something fails? What should the schedule look like?
Layer 2 — The Agent (The Chat/API Routing Layer)
The agent is the entity that receives intent and routes it to the right skill. In practice, this could be a Claude session, a GPT-4 API call, a custom system prompt with tool definitions, or a structured prompt template that maps inputs to outputs.
The key behavior: the agent interprets intent and selects the appropriate skill. "Research what our competitors published this week" → the agent knows to call the competitor-research browser skill, not the content-generation skill.
Most people live their entire AI life in this layer — they treat the agent as the endpoint, not as a router. That's the . The agent is powerful, but its job is to delegate, not to do everything itself.
Layer 3 — The Orchestra (The Skill Library)
The orchestra is the collection of pre-built, reusable skills the agent can call. Each skill does one thing well and returns a predictable output — usually structured JSON.
Skills can be browser automation tasks (navigate to a page, extract data, take an action), data transforms (clean a JSON payload, summarize a document, classify a list), or integrations (post to Discord, write to a database, trigger a webhook).
The power of a skill library is . A well-written browser skill for extracting job postings from LinkedIn works every time you call it, across every project that needs job data. You write it once — or more often, you install it from a community library — and it pays dividends indefinitely.
The community dimension matters. Browser skills break when sites change their HTML structure. A community-maintained skill library gets fixed by the community, not just by you. That's a maintenance model that scales.
Layer 4 — The Score (The Orchestration OS)
The score is the orchestration layer: routing, memory, and scheduling. It answers three questions:
- Which skill runs when? The routing logic. Note the division of labor: the agent does the in-the-moment intent-to-skill selection for a given task, while the score owns the standing rules — when workflows fire, what parameters and state they carry, and what is remembered between runs. When the agent determines that a task needs competitor research, the score tells it which skill to invoke and with what parameters.
- What gets remembered? Memory. The output from Monday's research run needs to be available to Tuesday's content-generation step. The score stores and surfaces that state.
- When does this repeat? Scheduling. A workflow that runs on demand is useful. A workflow that runs every Monday at 7 AM without you touching it is a system.
Without the score, every workflow is a one-shot interaction. The agent does something once, the output disappears, and tomorrow you start over. The score is what makes a collection of skills into a workforce.
Layer 5 — The Encore (Compounding 24/7 Output)
The encore is the of all four layers working together over time. When the conductor has designed a good system, the agent routes reliably, the orchestra executes skills accurately, and the score handles memory and scheduling — the result compounds.
Each week the system knows more than the previous week. Each day it produces output that feeds the next day's work. The stack runs while you sleep. Your leverage grows without your hourly involvement.
The encore isn't a component you install — it's what falls out of the other four layers being in place and functioning correctly.
Practical Application
Here's how the five layers map to a concrete use case: a competitive intelligence workflow.
Layer 1 (Conductor): You decide the outcome — every Monday morning you want a digest of competitor blog activity from the past 7 days.
Layer 2 (Agent): A Claude session with tool definitions receives a scheduled trigger and routes it to the appropriate browser skill based on the task description.
Layer 3 (Orchestra): A browser automation skill navigates to each competitor's blog, extracts recent post titles, dates, and excerpts, and returns them as structured JSON objects.
Layer 4 (Score): The orchestration layer — in this case, a scheduler (any tool that runs a command at a set time — on a Mac this is launchd, on Linux it's cron) on an always-on machine plus a memory store — fires the agent on Monday at 7 AM, passes last week's digest as context ("don't repeat what we surfaced last week"), and routes the output to a Discord channel.
Layer 5 (Encore): After four weeks, the digest includes a section on patterns you've observed across competitor content — because the memory layer has accumulated enough history to surface them. The system is smarter than it was on day one.
Remove any single layer and this breaks. No skill library means the agent can't extract structured data. No orchestration means it never runs automatically. No memory means each digest is ignorant of the previous week.
Common Mistakes
Skipping Layer 4 and calling it done. Building skills (Layer 3) without the orchestration layer (Layer 4) gives you a collection of tools that requires manual invocation every time. It's better than nothing, but it's not a workforce.
Conflating the agent with the conductor. The agent is a router. The conductor is the human designing the system. Many beginners expect the agent to figure out the high-level strategy — it won't, reliably. You have to design that.
Treating Layer 5 as a feature you add later. Compounding output is the result of building layers 1-4 correctly from the start. If you're not thinking about memory and scheduling from the beginning, you'll need to retrofit them, which is harder.
Building custom Layer 3 skills before checking if community skills exist. A pre-built, community-maintained skill is almost always better than a one-off you write yourself — especially for browser automation where HTML changes break things.
Summary
- The Conductor Stack has five layers: Conductor (you), Agent (intent routing), Orchestra (skill library), Score (orchestration OS), Encore (compounding output)
- Each layer is load-bearing — the system degrades when any one is missing
- Layer 2 is where 99% of users stop; the real leverage is in layers 3-5
- The conductor designs the system; the agent executes routing; the orchestra runs skills; the score manages memory and scheduling; the encore is what falls out when all four work together
- Community skill libraries (Layer 3) and a reliable orchestration layer (Layer 4) are the two highest-leverage investments for beginners building toward Layer 5
What's Next
Now that you have the full map, we'll zoom in on Layer 3 — the skill library. The next lesson gets practical: what a browser skill actually does, how it works, and a concrete example of having one pull structured data from a real page.