2 · The 8-Layer Meta-Model

Every AI system is some combination of these eight layers. The layers are the skeleton; the concept ontology supplies the node types that populate them.

L1  Actors          Who participates
L2  Cognition       How thinking happens
L3  Execution       How tools are reached and governed in-flight
L4  Knowledge       What the system knows / carries
L5  Coordination    How work moves between agents
L6  Runtime         What executes and durably runs the system
L7  Governance      What is allowed, blocked, budgeted
L8  Infrastructure  What physically runs the work

Node shapes — a shape per layer

Renderers draw a distinct shape per layer, so you can tell an agent from a model from a tool at a glance. The shapes are deliberately simple (easy to draw on a whiteboard) and distinguishable in black & white — colour is a bonus, never the only signal. The shape is the legend for the layer:

Layer	Shape	Examples
L1 Actors	stadium / pill	`human`, `agent`, `subagent`, `ui`
L2 Cognition	ellipse	`model`, `planner`, `router`, `judge`
L3 Execution	hexagon	`tool`, `api`, `mcp`, `protocol`, `middleware`
L4 Knowledge	cylinder	`data`, `memory`, `rag`, `context`, `file`
L5 Coordination	parallelogram	`queue`, `event`, `flow`, `graph`
L6 Runtime	rounded rectangle	`harness`, `runtime`, `framework`, `sandbox`, `driver`
L7 Governance	diamond	`policy`, `decision`, `constraint`, `approval`
L8 Infrastructure	sharp rectangle	`browser`, `shell`, `fs`, `container`, `vm`
Evaluation	trapezoid	`bench`, `metric`, `eval`, `log`, `monitor`

Because the distinction is carried by shape, a printed (mono) diagram stays just as readable.

L1 · Actors — who participates

Humans, agents, and subagents. The subagent is the commonly-missed primitive: Claude Code calls them subagents, OpenAI's Agents SDK expresses them as handoffs, Google ADK as hierarchies, CrewAI as roles — all are the same idea.

[human: User]
[agent: Researcher]
[agent: Reviewer]
[subagent: Browser Agent]

[agent: Manager] -> [subagent: Researcher]
[agent: Manager] -> [subagent: Writer]

L2 · Cognition — how thinking happens

Reasoning primitives that recur across CrewAI, LangGraph, OpenAI Agents SDK, Claude Code, and Google ADK:

[planner]      # decomposes the goal into a plan
[reflector]    # critiques its own intermediate output
[critic]       # adversarial review of a candidate
[judge]        # scores / selects among candidates
[router]       # routes a request to the right path
[synth]        # synthesizes multiple outputs into one
[decompose]    # splits a task into subtasks

L3 · Execution — reaching tools safely

The layer most people miss. Between an agent and 500 tools sit selection and interception primitives. Tool Selector — you do not want the LLM seeing every tool. Shortlist first (MCP Gateway, Composio, OpenAI tool selection, custom middleware):

[agent] -> [selector] -> [mcp]
[selector] -> [tool: Slack]
[selector] -> [tool: Notion]
[selector] -> [tool: Gmail]

Tool Middleware — the request passes through policy and transforms before the tool runs: Agent -> Policy -> Sanitizer -> Tool. Examples: PII scrubber, permission checker, rate limiter, context trimmer, audit logger. Interceptors — trust/guard layers (AgentTrust, ALTK) that emit verdicts:

[agent] -> [interceptor] -> [tool]
# verdicts: allow | warn | block | review

L4 · Knowledge — what the system carries

More than "data": data, memory, cache, skill, prompt, index, embedding. Skills — reusable capabilities being standardized industry-wide (Claude Skills, Claude Code Skills, Cursor Rules): [skill: code_review], [skill: legal_review]. Prompt libraries — [prompt: support_system], [prompt: legal_system]. Context Pack — the bundle assembled before model invocation: prompt + memory + docs + MCP resources, composed into [context].

L5 · Coordination — how work moves

The most important missing category in prior notations.

[agent:a] => [agent:b]   # handoff / escalation (OpenAI SDK primitive)
[a2a]                    # agent-to-agent protocol
[flow]                   # durable workflow (n8n, Temporal, Inngest)
[graph]                  # runtime graph (LangGraph primitive)
[event] / [queue] / [stream]   # event bus (Kafka, SNS, RabbitMQ)

L6 · Runtime — what executes the system

Framework ≠ runtime ≠ harness. [framework] — opinionated construction model: CrewAI, LangChain, PydanticAI, AutoGen, OpenAI SDK, Google ADK. [runtime] — execution engine with durability, checkpointing, streaming, persistence: LangGraph, Temporal, Inngest. [harness] — batteries-included agent environment bundling prompts, tools, planning, filesystem, permissions, and loops: Claude Code, Claude Agent SDK, OpenCode, Goose, OpenClaw, DeepAgents. [sandbox] — isolation boundary: Docker, Firecracker, browser sandbox.

L7 · Governance — what is allowed

Most diagrams ignore this, which is a serious mistake.

[policy]      # rules the system enforces
[guardrail]   # runtime safety constraints
[approval]    # human/admin gates
[budget]      # token / cost / runtime budgets
trust:        # trust-boundary grouping

L8 · Infrastructure — what physically runs work

This is where Playwright belongs — not under "tools," but under execution infrastructure.

[browser]     # Playwright, Browserbase, Steel.dev
[desktop]     # Claude Computer Use, OpenAI Operator
[shell]
[fs]
[vm]
[container]