The 8 Primitives

A complete guide to the 8 building blocks that make up the agent system. Everything the system does — every automation, every decision, every workflow — is built from combinations of these primitives.

Analogy: Think of primitives like LEGO brick types. There are only a few shapes (2x4, 2x2, flat, angled), but you can build anything by combining them. The system has 8 “brick types” — once you understand them, you understand the whole system.

  ┌─────────────────────────────────────────────┐
  │  THE FOUNDATION                             │
  │                                             │
  │  1. Global Context   2. Interactions        │
  │     (your profile       (every conversation)│
  │      + system map)                          │
  └─────────────────────────────────────────────┘
  ┌─────────────────────────────────────────────┐
  │  ABOUT THE WORK                             │
  │                                             │
  │  3. Workflows        4. Workflow Context    │
  │     (the processes)     (the playbooks)     │
  │                                             │
  │  5. Data & Credentials                      │
  │     (the connections)                       │
  └─────────────────────────────────────────────┘
  ┌─────────────────────────────────────────────┐
  │  ABOUT THE SYSTEM                           │
  │                                             │
  │  6. Skills           7. Feedback            │
  │     (reliable ops)      (learning layer)    │
  │                                             │
  │  8. Metrics                                 │
  │     (measurements)                          │
  └─────────────────────────────────────────────┘

Primitive 1: Global Context

What it is: The foundation layer that orients the entire system. It contains three things: who YOU are (self-knowledge), what EXISTS in the system (the system map), and how your life is ORGANIZED (domain modules).

Analogy: Imagine onboarding a brilliant new executive assistant. On day one, you’d give them three things: (1) a personal briefing about you — your preferences, constraints, goals; (2) a map of the office — where every file, tool, and resource lives; (3) a breakdown of your life areas — “here’s how I organize work, health, finance, family.” That’s Global Context.

The Three Layers

Layer A: Self-Knowledge (About You)

Everything the system needs to know about you as a person — the things that data sources and interactions alone can’t capture. You actively write and maintain this.

The Self-Knowledge Checklist:

Key principle: Anything a new EA would need to learn in their first week belongs here. If you find yourself correcting the system about something personal, that correction belongs in self-knowledge.

Layer B: System Map (The Directory of Everything)

A complete, always-current directory of everything in the system — all agents, skills, workflows, data sources, and credentials.

Analogy: Like the directory sign in a hospital lobby. A doctor who’s new to the building can instantly find radiology (3rd floor), pharmacy (ground floor). The system map does the same for agents navigating your setup.

Layer C: Domain Modules (Your Life Areas)

Your life organized into modular areas — work, health, finance, creative, family, admin — each with its own context.

Why modular? Loading everything for every task wastes resources. Domain modules let the system load just what’s relevant. Like tabs in a browser — you don’t open all your bookmarks at once.

Primitive 2: Interactions

What it is: Every conversation you have with the system — your prompts, the agent’s responses, the decisions made.

Analogy: Like meeting transcripts. Each conversation is recorded, and over time they become a rich source of insight about what you care about, what problems keep coming up, and how your thinking evolves.

What it contains:

• What you asked (human prompts)
• What was done (agent responses)
• Decisions made during the interaction
• Session metadata (when, which agent, what domain)
• Implicit signals (what topics come up repeatedly)

Why it matters: Interactions are the raw material for learning. A thousand interactions contain more truth about your priorities than any goals document you write.

Primitive 3: Workflows

What it is: Outcome-oriented sequences of steps that accomplish a goal. Each workflow coordinates multiple parts of the system, keeping your involvement minimal.

Analogy: Like a well-designed business process. You say “prepare the board deck” and a series of actions kick into motion — research, drafting, formatting, review — with you only stepping in for key decisions.

Types of workflows:

Why it matters: Workflows are WHERE VALUE IS CREATED. A single well-designed workflow can save hours per week.

Primitive 4: Workflow Context

What it is: The “how-to” knowledge that tells the system HOW to execute work correctly. Not about you (that’s global context) — about the process itself.

Analogy: Think of a film production. The production bible tells everyone the tone, schedule, and quality standards. But the director, cinematographer, and editor each have their OWN context too. Everyone shares the production bible, but each person also has specialized instructions.

The Context Hierarchy

  ┌─────────────────────────────────────────────┐
  │  Tier 1: Global Context                     │
  │  Always loaded. About YOU.                  │
  └─────────────────────────────────────────────┘
  ┌─────────────────────────────────────────────┐
  │  Tier 2: Workflow Context                   │
  │  Shared by all agents in this workflow.     │
  └─────────────────────────────────────────────┘
  ┌─────────────────────────────────────────────┐
  │  Tier 3: Agent Context                      │
  │  Specific to each agent's role.             │
  └─────────────────────────────────────────────┘

Real example — “Weekly Review” workflow:

Each agent is focused. The data collector doesn’t need to know the writing template. The writer doesn’t need to know which data sources were queried.

Primitive 5: Data & Credentials

What it is: Everything the system can access — files, databases, email, calendar, APIs — plus the credentials needed to access them.

Analogy: Like giving your assistant keys to the office, access to the filing cabinet, and login credentials for your accounts. The more access they have, the more they can do independently.

What it contains:

• Local data — Files on your computer
• Cloud data — Email, calendar, documents
• APIs — Connections to external services
• Credentials — API keys, login tokens (stored securely)
• Knowledge base — Everything the system has collected and organized

Why it matters: Data is fuel. An agent with access to your calendar and email can prepare a morning brief. Without that access, it can only ask you questions. Each credential you add unlocks new capabilities.

Primitive 6: Skills

What it is: Reliable, repeatable tools that do the same thing perfectly every time. Collecting data, formatting reports, sending notifications — these are skills.

Analogy: Like a calculator vs. a mathematician. The mathematician (AI agent) decides WHAT to calculate and WHY. The calculator (skill) does the computation perfectly every time. You want both.

The skills vs agents distinction:

Why it matters: Skills handle the routine parts so AI agents can focus on reasoning. A system with good skills is faster, cheaper, and more reliable.

Primitive 7: Feedback Mechanisms

What it is: The layer that makes the system improve over time. Feedback evaluates outcomes, detects patterns, and feeds learnings back into the system.

Analogy: Like a sports coach reviewing game film. The players (agents) play the game. The coach (feedback layer) watches the replays, identifies what worked and what didn’t, and adjusts the game plan. Without the coach, the team never gets better.

The feedback loop:

  Actions ──▶ Outcomes ──▶ Analysis ──▶ Updates ──▶ Better Performance
     │                                                               │
     └───────────────────────────────────────────────────────────────┘

What it evaluates:

• Did the agent accomplish what was asked? How well?
• What keeps going wrong? What keeps going right?
• Which approaches work best for which tasks?

Why it matters: This is what separates a static tool from a living system. Without feedback, the system stays the same quality forever. With feedback, it compounds — getting meaningfully better every week.

Primitive 8: Metrics

What it is: Quantitative measurements that make abstract things concrete. How much time was saved? How many tasks were completed? What’s improving?

Analogy: Like a dashboard in your car. Without metrics, you’re driving blind — you feel like things are going okay but have no proof. With metrics, you can see exactly how fast you’re going and whether the engine is healthy.

Types of metrics:

Relationship to Feedback: Metrics are the RAW DATA; feedback mechanisms are the ANALYSIS. Metrics tell you “email triage took 45 minutes this week.” Feedback tells you “that’s 15 minutes longer than last week because you added 3 new subscriptions — should we auto-archive those?”

How the Primitives Work Together

  ┌───────────────────────────────────┐
  │  Global Context                   │
  │  (orients everything)             │
  └───────────────────────────────────┘
                  │
                  ▼
  ┌───────────────────────────────────┐
  │  Workflows                        │
  │  (define the work)                │
  └───────────────────────────────────┘
                  │
                  ▼
  ┌───────────────────────────────────┐
  │  Workflow Context                 │
  │  (the how-to)                     │
  └───────────────────────────────────┘
                  │
                  ▼
  ┌───────────────────────────────────┐
  │  Skills + Data                    │
  │  (execute the work)               │
  └───────────────────────────────────┘
                  │
                  ▼
  ┌───────────────────────────────────┐
  │  Interactions                     │
  │  (capture what happened)          │
  └───────────────────────────────────┘
                  │
                  ▼
  ┌───────────────────────────────────┐
  │  Metrics                          │
  │  (measure what happened)          │
  └───────────────────────────────────┘
                  │
                  ▼
  ┌───────────────────────────────────┐
  │  Feedback                         │
  │  (analyze & improve)              │
  └───────────────────────────────────┘
                  │
                  │  Updates context,
                  │  refines workflows
                  │
                  └──────────▶ Back to top

The cycle:

1. Global Context orients everything — who you are, what exists, what domain
2. Workflows define what needs to happen
3. Workflow Context provides the how-to instructions
4. Skills execute the reliable parts, Data & Credentials provide access
5. Interactions capture what happened
6. Metrics measure what happened
7. Feedback analyzes everything and improves the system
8. Back to step 1, but better — the system compounds

Why Agents Aren’t a Primitive

Agents appear throughout the system but aren’t one of the 8 primitives. This is intentional. Agents are the WORKERS that use the primitives — like employees in a company. The company’s assets are the building (data), the processes (workflows), the institutional knowledge (context), the tools (skills), and the performance reviews (feedback). Employees use all of these, but they aren’t an asset category themselves.

Explore Further

• Building Blocks Overview — The simplified visual overview
• How Context Works — Deep dive on the 3-tier context model
• How It Learns — How feedback makes the system better
• Developer Guide — Technical implementation details