Divya van Mahajan

How to Build a Personal Agentic Operating System

ai-daily-brief-podcast

How to Build a Personal Agentic Operating System

Overview

This episode of the AI Daily Brief (recorded April 25, 2026) introduces Agent OS — a free, self-directed training program focused on building a personal agentic operating system (Agent OS) for knowledge workers. The primary speaker is Nufar Gaspar, presenting alongside the show’s host (NLW). The core argument is that as every major AI agentic tool converges on the same capabilities, the system underneath the tool — not the tool itself — becomes the most important determinant of AI productivity and value. The episode uses the concrete example of building a Chief of Staff agent to walk through each layer of the OS.

Source video URL: Not provided.

Prerequisites

  • Basic familiarity with AI assistant or agentic tools (e.g., Claude Code, Cursor, OpenAI Codex, OpenClaw/Claude)
  • Understanding of what a large language model (LLM) does at a basic level
  • Comfort with creating and editing plain text or markdown files
  • Optional but helpful: prior exposure to Model Context Protocol (MCP), prompt engineering concepts, or the AIDB “Claw Camp” program
  • No coding expertise required — the framework is built on human-readable text files

Main Points

The Convergence of Agentic Tools Makes the Underlying System the Key Variable

  • Every major agentic platform (Cursor, Claude Code, OpenClaw, Codex, WinSurf, Hermes) is converging on the same feature set: agents, memory systems, file reading, background execution, and external integrations.
  • Because tools are becoming interchangeable, the tool choice is increasingly the least important decision.
  • What differentiates outcomes is the system built underneath the tool: the Agent OS.
  • The Agent OS is portable — switching tools requires only pointing the new tool at the same folder of text files.

What an Agent OS Is

  • An Agent OS is a structured collection of plain text files and configurations that define who you are, what you know, how you work, and what your agents can reach.
  • All agents built on top of the OS inherit the full foundation, making each successive agent faster and more capable to build.
  • The framework applies equally to coding and knowledge work (strategy, communications, operations, research, decision-making).

The Seven Layers of the Agent OS

Layer 1: Identity

  • A text file (named variously: soul, agents.md, .claude, copilot-instructions) that is read first before every interaction.
  • Defines: who you are, how you communicate (direct vs. diplomatic, bullets vs. prose), what you value, and hard rules (e.g., “never send external email without showing me a draft,” “always tell me what I’m not seeing”).
  • How to build it: Brain-dump to an AI; ask it to interview you with ~15 questions; draft from your answers; ship a 70% version and patch over three weeks.

Layer 2: Context

  • Represents what you know — org chart, roadmap, customer segments, stakeholders, priorities — information that no model improvement will ever supply on its own.
  • Structured as 3–5 focused, single-page files (e.g., my-team.md, my-quarter.md, my-stakeholders.md), each dated and kept fresh.
  • Avoid the trap of writing one massive 40-page document; treat context curation as an ongoing practice, not a one-time project.
  • Rule of thumb: every time you re-explain something about your situation to AI, that thing belongs in a context file.

Layer 3: Skills

  • Reusable instruction sets for recurring workflows: weekly status updates, meeting prep, stakeholder emails, decision memos, daily briefs, etc.
  • Format: “When I say [trigger], do [process] using [sources] and produce output in [format].”
  • A skill eliminates re-explanation, re-pasting sources, and inconsistent voice every session.
  • Start with a minimal viable skill; refine over a week of real use.
  • Example skills for a Chief of Staff agent: pre-read, daily-brief, voice-match, commitment-tracker.

Layer 4: Memory

  • Every major agentic platform is actively investing in memory; capabilities are improving rapidly.
  • Minimum requirement: understand how your specific tool’s memory works (ask it directly: “What do you remember between sessions? What do you forget?”).
  • Known gaps: cross-session retention, context window interactions with stored memory, what the agent chooses to retain vs. discard.
  • Advanced practice: maintain deliberate memory logs for major decisions, relationship context, and working-process improvements — don’t rely solely on the agent’s automatic memory pickup.
  • Memory is what makes all other layers persist across sessions.

Layer 5: Connections

  • How agents reach external systems: email, calendar, Slack, Jira, Salesforce, databases.
  • Primary mechanism: Model Context Protocol (MCP) — an open standard supported by most major tools; also CLI tools, direct APIs, and scripting.
  • Security rule: Start with read-only access. Add write access only after observing agent behavior for several weeks and building trust.
  • Risk scales with capability — an agent with loose permissions and Slack access can inadvertently expose private notes, opinions, or draft feedback.
  • Practical guidance: use least-privilege connections; consult IT before connecting work systems.

Layer 6: Verification

  • The most dangerous failure mode is an agent that is confidently wrong and whose output gets shipped unreviewed.
  • Every agent task type needs its own quick checklist (3–5 checks, typically under one minute): tone match for emails, fact-check for analysis, number validation for data tasks.
  • Periodic system audits: identify stale context files, unused skills, and agents needing updated instructions — roughly every 8 weeks minimum.
  • Discipline: you can verify just high-stakes outputs once low-stakes tasks have built trust.

Layer 7: Automations

  • Optional but powerful: scheduled tasks the agent runs without active user prompting (e.g., 7 a.m. daily summary, Slack monitoring pings, cron jobs).
  • Rules: Only automate workflows you have run manually and trust; start with automations that produce drafts for review, not outputs sent directly to others; always add logs so you know what ran and what it did.
  • This is the highest-risk layer if misconfigured.

The Compounding Return on the Agent OS

  • The first agent (e.g., Chief of Staff) is the hardest to build because you are constructing the OS and the agent simultaneously — potentially a weekend of work.
  • Each subsequent agent (research agent, board prep agent, content specialist) inherits the full OS foundation and takes only an afternoon to build.
  • Agents can share state via a central hub, enabling a Chief of Staff agent to supervise specialist agents.
  • The OS compounds in value over time; without the audit discipline (Layer 6), it has a shelf life of roughly eight weeks before going stale.

The Agent OS Program

  • Agent OS is a free, self-directed, build-based training program — the third in AIDB’s series (after AIDB New Year and Claw Camp).
  • Unlike Claw Camp (OpenClaw-specific), Agent OS is platform-, model-, and harness-neutral.
  • 10 build projects; bring your own agentic tool.
  • Link available in show notes and the AIDB training website.

Key Concepts

  • Agent OS (Agentic Operating System): A layered system of text files and configurations that defines identity, context, skills, memory, connections, verification, and automations — forming the foundation all agents run on top of.
  • Identity file: A text file read first by any agentic tool that defines the user’s communication style, values, and hard rules for agent behavior.
  • Context curation: The ongoing practice of maintaining focused, dated files containing situation-specific knowledge (org charts, priorities, stakeholders) that AI cannot retrieve from the public internet.
  • Skill: A reusable, trigger-based instruction set for a recurring knowledge work workflow (e.g., meeting pre-read, daily brief).
  • Model Context Protocol (MCP): An open standard for connecting AI agents to external systems such as email, calendars, and project management tools.
  • Least-privilege access: A security principle of granting agents the minimum permissions needed (e.g., read-only before read-write) to limit risk surface.
  • Verification layer: A per-task checklist and periodic system audit practice to catch confident-but-wrong agent outputs and prevent system staleness.
  • Automations layer: Scheduled, unattended agent tasks (cron jobs, heartbeat triggers) that run without active user prompting.
  • Chief of Staff agent: A concrete example agent that reviews inbox, prepares meeting pre-reads, tracks commitments, flags blind spots, and manages other agents.
  • Claw Camp: A prior AIDB training program focused specifically on OpenClaw; predecessor to Agent OS.

Summary

Nufar Gaspar argues that the rapid convergence of agentic AI tools — where Cursor, Claude Code, OpenClaw, Codex, and others are all building the same core capabilities — means that tool selection is becoming an increasingly irrelevant decision. What determines how much value a knowledge worker extracts from any of these platforms is the structured system built underneath them: the Agentic Operating System. This OS consists of seven portable, text-file-based layers — identity, context, skills, memory, connections, verification, and automations — that collectively tell any agent who the user is, what they know, how they work, what they can access, and how outputs should be checked. Using a Chief of Staff agent as a running example, the talk demonstrates that building the OS once creates a compounding foundation: each new agent inherits the full stack and becomes progressively faster to build and more immediately useful. The central takeaway is that professionals who invest in building and maintaining this foundation now will see it compound in value across every tool upgrade and new capability release, while those who do not will continue starting over each time a new platform emerges.